use std::sync::Arc;

use anyhow::{Result, anyhow};
use pollster::FutureExt;
use twgpu::{
    Camera, GpuCamera,
    map::{GpuMapData, GpuMapStatic},
    shared::Rng,
    sprites::{ParticleData, SpriteTextures, SpritesData, SpritesStatic},
    textures::Samplers,
};
use wgpu::{
    Backends, DeviceDescriptor, Features, Instance, InstanceDescriptor, Limits, MemoryHints,
    PowerPreference, RequestAdapterOptions, TextureFormat,
};
use winit::window::Window;

pub struct Renderer<'a> {
    window: &'a Window,
}

impl<'a> Renderer<'a> {
    pub fn new(window: &'a Window) -> Result<Self> {
        let texture_format = TextureFormat::Bgra8UnormSrgb;

        let instance = Instance::new(InstanceDescriptor {
            backends: Backends::all(),
            ..Default::default()
        });

        let surface = instance.create_surface(window)?;

        let adapter = instance
            .request_adapter(&RequestAdapterOptions {
                power_preference: PowerPreference::HighPerformance,
                compatible_surface: Some(&surface),
                force_fallback_adapter: false,
            })
            .block_on()
            .ok_or(anyhow!("no adapter found"))?;

        eprintln!("Adapter {:#?}", adapter.limits());
        let (device, queue) = adapter
            .request_device(
                &DeviceDescriptor {
                    label: None,
                    required_features: Features::default(),
                    required_limits: Limits::default(),
                    memory_hints: MemoryHints::Performance,
                },
                None,
            )
            .block_on()?;

        let samplers = Arc::new(Samplers::new(&device));
        let mut camera = Camera::new(1.);
        let gpu_camera = Arc::new(GpuCamera::upload(&camera, &device));

        let map_static = GpuMapStatic::new(texture_format, &device);
        let map_data = GpuMapData::upload(&twmap, &device, &queue);
        let map_render =
            map_static.prepare_render(&twmap, &map_data, &gpu_camera, &samplers, &device);

        let sprites_static = SpritesStatic::new(texture_format, &device);
        let mut sprites_data = SpritesData::new(&device);
        let mut particle_data = ParticleData::new(demo.current_time(), &device);
        let mut textures = SpriteTextures::new(&device, &queue, &gpu_camera, &samplers);
        let mut rng = Rng::new(0);
        init_sprite_textures(&mut textures, twmap.version, &device, &queue)?;
        let blit = Arc::new(Blit::new(&device));
        let mut skin_manager = SkinManager::new(blit, &mut textures, device.clone(), queue.clone());

        Self { window }
    }
    pub fn redraw() {}
}