use log::warn;
use serde::{Deserialize, Serialize};
use serde_json::from_reader;
use smallvec::{smallvec, SmallVec};
use space_crush_common::misc::{Vfs, WorldHelper as _};
use specs::World;

use crate::{misc::VirtualKeyCode, Error};

#[derive(Debug, Default, Serialize, Deserialize)]
pub struct Config {
    #[serde(default)]
    pub video: Video,

    #[serde(default)]
    pub input: Input,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Video {
    #[serde(default = "defaults::resolution")]
    pub resolution: (u32, u32),
    #[serde(default = "defaults::multisampling")]
    pub multisampling: u16,
    #[serde(default = "defaults::fullscreen")]
    pub fullscreen: bool,
    #[serde(default = "defaults::windowed")]
    pub windowed: bool,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct Input {
    #[serde(default = "defaults::key_camera_move_up")]
    pub key_camera_move_up: VirtualKeyCodes,
    #[serde(default = "defaults::key_camera_move_down")]
    pub key_camera_move_down: VirtualKeyCodes,
    #[serde(default = "defaults::key_camera_move_left")]
    pub key_camera_move_left: VirtualKeyCodes,
    #[serde(default = "defaults::key_camera_move_right")]
    pub key_camera_move_right: VirtualKeyCodes,

    #[serde(default = "defaults::speed_camera_move")]
    pub speed_camera_move: f32,
    #[serde(default = "defaults::speed_camera_zoom")]
    pub speed_camera_zoom: f32,
}

type VirtualKeyCodes = SmallVec<[VirtualKeyCode; 2]>;

impl Config {
    pub fn new(world: &World) -> Result<Self, Error> {
        let vfs = world.resource::<Vfs>()?;
        let config = match vfs.join("config.json")?.open_file() {
            Ok(mut file) => from_reader(&mut file)?,
            Err(err) => {
                warn!(
                    "Unable to load config file, falling back to default config: {}",
                    err
                );

                Config::default()
            }
        };

        Ok(config)
    }
}

impl Default for Video {
    fn default() -> Self {
        Self {
            resolution: defaults::resolution(),
            multisampling: defaults::multisampling(),
            fullscreen: defaults::fullscreen(),
            windowed: defaults::windowed(),
        }
    }
}

impl Default for Input {
    fn default() -> Self {
        Self {
            key_camera_move_up: defaults::key_camera_move_up(),
            key_camera_move_down: defaults::key_camera_move_down(),
            key_camera_move_left: defaults::key_camera_move_left(),
            key_camera_move_right: defaults::key_camera_move_right(),

            speed_camera_move: defaults::speed_camera_move(),
            speed_camera_zoom: defaults::speed_camera_zoom(),
        }
    }
}

mod defaults {
    use super::*;

    pub fn resolution() -> (u32, u32) {
        (1280, 720)
    }

    pub fn multisampling() -> u16 {
        0
    }

    pub fn fullscreen() -> bool {
        true
    }

    pub fn windowed() -> bool {
        true
    }

    pub fn key_camera_move_up() -> VirtualKeyCodes {
        smallvec![VirtualKeyCode::W, VirtualKeyCode::Up]
    }

    pub fn key_camera_move_down() -> VirtualKeyCodes {
        smallvec![VirtualKeyCode::S, VirtualKeyCode::Down]
    }

    pub fn key_camera_move_left() -> VirtualKeyCodes {
        smallvec![VirtualKeyCode::A, VirtualKeyCode::Left]
    }

    pub fn key_camera_move_right() -> VirtualKeyCodes {
        smallvec![VirtualKeyCode::D, VirtualKeyCode::Right]
    }

    pub fn speed_camera_move() -> f32 {
        500.0
    }

    pub fn speed_camera_zoom() -> f32 {
        100.0
    }
}