use crate::input::Input;
use crate::scene::Scene;
use crate::audio::{Audio, AlAudio, NullAudio, AudioError, Sound};
use crate::renderer::{Renderer, RendererError, RendererNewInfo, Sheet, Shader};
#[cfg(feature = "imgui_integration")] use crate::imgui_handler::ImGuiHandler;
#[cfg(feature = "default_logger")] use crate::doglog;

use sdl2::event::Event;
use sdl2::event::WindowEvent;
use sdl2::keyboard::Scancode;
use sdl2::keyboard::Mod as KeyboardMod;
#[cfg(feature = "graphical_panic")] use sdl2::messagebox;

#[cfg(feature = "graphical_panic")] use std::panic::PanicInfo;
#[cfg(feature = "graphical_panic")] use backtrace::Backtrace;

use keeshond_datapack::DataStore;
use keeshond_datapack::source::SourceManager;

#[cfg(feature = "imgui_integration")] use imgui;

use std::time::{Instant, Duration};
use std::rc::Rc;
use std::cell::RefCell;

const MILLISECONDS_PER_NANOSECOND : f64 = 0.000001;

#[derive(Debug)]
pub enum Sdl2Subsystem
{
    Main,
    Event,
    Video
}

#[derive(Debug, Fail)]
pub enum InitError
{
    #[fail(display = "Failed to initialize SDL {:?} subsystem: {}", _0, _1)]
    Sdl2InitError(Sdl2Subsystem, String),
    #[fail(display = "Failed to initialize renderer: {}", _0)]
    RendererInitError(RendererError),
    #[fail(display = "Failed to initialize audio: {}", _0)]
    AudioInitError(AudioError),
    #[fail(display = "Failed to initialize imgui: {}", _0)]
    ImguiInitError(String)
}

#[cfg(feature = "graphical_panic")]
fn panic_hook(info : &PanicInfo)
{
    // Get error message if that's what the payload happens to be
    let message : &str = match info.payload().downcast_ref::<String>()
    {
        Some(s) => s,
        None => match info.payload().downcast_ref::<&str>()
        {
            Some(s) => s,
            None => "No reason was given.",
        }
    };
    // Format with file/line info if available
    let mut message = match info.location()
    {
        Some(location) => format!("A panic error occurred on {}:{}: \n{}",
                                location.file(),
                                location.line(),
                                message),
        None => format!("A panic error occurred: \n{}", message),
    };
    
    let bt = Backtrace::new();
    
    message = format!("{}\n\n{:?}", message, bt);
    
    gui_cli_message(&message, "Panic Error");
    
    std::process::exit(1);
}

#[allow(unused_variables)]
pub fn gui_cli_message(message : &str, title : &str)
{
    // Print to console first in case something weird happens
    println!("{}", message);
    
    #[cfg(feature = "graphical_panic")]
    {
        // Show dialog box with panic
        match messagebox::show_simple_message_box(messagebox::MESSAGEBOX_ERROR, title, &message[..], None)
        {
            Ok(_) => (),
            Err(_) => println!("(Messagebox could not be displayed)"),
        };
    }
}

fn read_options() -> getopts::Matches
{
    let args : Vec<String> = std::env::args().collect();
    let options = getopts::Options::new();
    
    let match_result = options.parse(&args[1..]);
    
    match match_result
    {
        Ok(_) => (),
        Err(fail) =>
        {
            let message = format!("{:?}\n{}",
                                  fail,
                                  options.usage("Command parsing failed. Run without options to use defaults."));
            gui_cli_message(&message, "Commandline Help");
            std::process::exit(1);
        }
    }
    
    match_result.unwrap()
}

pub struct GameloopStopwatch
{
    jiffies : Instant,
    jiffies_this_frame : Duration,
    jiffies_this_second : Duration,
    tics_this_frame : u32,
    tics_this_second : u32,
    frames_this_second : u32,
    in_frame : bool
}

impl GameloopStopwatch
{
    pub fn new() -> GameloopStopwatch
    {
        GameloopStopwatch
        {
            jiffies : Instant::now(),
            jiffies_this_frame : Duration::new(0, 0),
            jiffies_this_second : Duration::new(0, 0),
            tics_this_frame : 0,
            tics_this_second : 0,
            frames_this_second : 0,
            in_frame : false
        }
    }
    
    pub fn begin_frame_timing(&mut self)
    {
        if self.in_frame
        {
            return;
        }
        
        self.in_frame = true;
        
        self.jiffies = Instant::now();
        self.jiffies_this_frame = Duration::new(0, 0);
        self.tics_this_frame = 0;
    }
    
    pub fn end_frame_timing(&mut self)
    {
        if !self.in_frame
        {
            return;
        }
        
        self.in_frame = false;
        
        self.jiffies_this_frame = Instant::now() - self.jiffies;
        self.tics_this_second += self.tics_this_frame;
        self.jiffies_this_second += self.jiffies_this_frame;
        self.frames_this_second += 1;
    }
    
    pub fn tic(&mut self)
    {
        self.tics_this_frame += 1;
    }
    
    pub fn new_second(&mut self)
    {
        self.jiffies_this_second = Duration::new(0, 0);
        self.tics_this_second = 0;
        self.frames_this_second = 0;
    }
    
    pub fn jiffies_this_frame(&self) -> Duration
    {
        if self.in_frame
        {
            return Instant::now() - self.jiffies;
        }
        
        self.jiffies_this_frame
    }
    
    pub fn jiffies_this_second(&self) -> Duration
    {
        self.jiffies_this_second
    }
    
    pub fn tics_this_frame(&self) -> u32
    {
        self.tics_this_frame
    }
    
    pub fn tics_this_second(&self) -> u32
    {
        self.tics_this_second
    }
    
    pub fn frames_this_second(&self) -> u32
    {
        self.frames_this_second
    }
    
    pub fn average_ms(&self) -> f64
    {
        self.jiffies_this_second.as_nanos() as f64 * MILLISECONDS_PER_NANOSECOND / self.frames_this_second as f64
    }
}

pub struct GameResources
{
    sheet_store : DataStore<Sheet>,
    shader_store : DataStore<Shader>,
    sound_store : DataStore<Sound>
}

impl GameResources
{
    pub fn sheets(&self) -> &DataStore<Sheet>
    {
        &self.sheet_store
    }
    
    pub fn sheets_mut(&mut self) -> &mut DataStore<Sheet>
    {
        &mut self.sheet_store
    }
    
    pub fn shaders(&self) -> &DataStore<Shader>
    {
        &self.shader_store
    }
    
    pub fn shaders_mut(&mut self) -> &mut DataStore<Shader>
    {
        &mut self.shader_store
    }
    
    pub fn sounds(&self) -> &DataStore<Sound>
    {
        &self.sound_store
    }
    
    pub fn sounds_mut(&mut self) -> &mut DataStore<Sound>
    {
        &mut self.sound_store
    }
}

pub struct GameControl
{
    target_framerate : f64,
    frame_interpolation : bool,
    input : Input,
    renderer : Renderer,
    audio : Box<Audio>,
    next_scene : Box<Scene>,
    next_scene_waiting : bool,
    source_manager : Rc<RefCell<SourceManager>>,
    resources : GameResources,
    #[cfg(feature = "imgui_integration")]
    imgui_handler : ImGuiHandler
}

impl GameControl
{
    pub fn new(sdl_context : Option<&sdl2::Sdl>) -> Result<GameControl, InitError>
    {   
        let source_manager = Rc::new(RefCell::new(SourceManager::new()));
        let sheet_store = DataStore::new(source_manager.clone());
        let shader_store = DataStore::new(source_manager.clone());
        let sound_store = DataStore::new(source_manager.clone());
        
        let mut resources = GameResources { sheet_store, shader_store, sound_store };
        
        let mut renderer_new_info = None;
        let audio : Box<Audio>;
        
        if let Some(sdl) = sdl_context
        {
            let video_subsystem = try_or_else!(sdl.video(),
                |error| Err(InitError::Sdl2InitError(Sdl2Subsystem::Video, error)));
            
            audio = Box::new(try_or_else!(AlAudio::new(&mut resources),
                |error| Err(InitError::AudioInitError(error))));
            
            renderer_new_info = Some(RendererNewInfo
            {
                video_subsystem,
                resources : &mut resources
            });
        }
        else
        {
            audio = Box::new(NullAudio::new());
        }
        
        #[cfg(feature = "imgui_integration")]
        let mut imgui_handler = try_or_else!(ImGuiHandler::new(),
            |error| Err(InitError::ImguiInitError(error)));
        
        #[allow(unused_mut)] // mut used only by imgui feature
        let mut renderer = try_or_else!(Renderer::new(renderer_new_info),
            |error| Err(InitError::RendererInitError(error)));
        
        #[cfg(feature = "imgui_integration")]
        try_or_else!(renderer.control().init_imgui_renderer(imgui_handler.imgui_mut()),
            |error| Err(InitError::RendererInitError(error)));
        
        Ok(GameControl
        {
            target_framerate : 60.0,
            frame_interpolation : false,
            input : Input::new(),
            renderer,
            audio,
            next_scene : Box::new(Scene::new()),
            next_scene_waiting : false,
            source_manager,
            resources,
            #[cfg(feature = "imgui_integration")]
            imgui_handler
        })
    }
    
    pub fn target_framerate(&self) -> f64
    {
        self.target_framerate
    }
    
    pub fn set_target_framerate(&mut self, new_framerate : f64)
    {
        if new_framerate < 1.0 || new_framerate >= 1000.0
        {
            panic!("Target framerate must be between 1 and 1000.");
        }
        
        self.target_framerate = new_framerate;
    }
    
    pub fn frame_interpolation(&self) -> bool
    {
        self.frame_interpolation
    }
    
    pub fn set_frame_interpolation(&mut self, enabled : bool)
    {
        self.frame_interpolation = enabled;
    }
    
    pub fn input(&self) -> &Input
    {
        &self.input
    }
    
    pub fn input_mut(&mut self) -> &mut Input
    {
        &mut self.input
    }
    
    pub fn renderer(&self) -> &Renderer
    {
        &self.renderer
    }
    
    pub fn renderer_mut(&mut self) -> &mut Renderer
    {
        &mut self.renderer
    }
    
    pub fn audio(&self) -> &Box<Audio>
    {
        &self.audio
    }
    
    pub fn audio_mut(&mut self) -> &mut Box<Audio>
    {
        &mut self.audio
    }
    
    fn sync_audio_store(&mut self)
    {
        self.audio.sync_sound_store(&mut self.resources.sound_store)
            .expect("Audio backend store sync failed");
    }
    
    pub fn source_manager(&self) -> Rc<RefCell<SourceManager>>
    {
        self.source_manager.clone()
    }
    
    pub fn res(&self) -> &GameResources
    {
        &self.resources
    }
    
    pub fn res_mut(&mut self) -> &mut GameResources
    {
        &mut self.resources
    }
    
    #[cfg(feature = "imgui_integration")]
    pub fn imgui(&self) -> &imgui::ImGui
    {
        self.imgui_handler.imgui()
    }
    
    #[cfg(feature = "imgui_integration")]
    pub fn imgui_mut(&mut self) -> &mut imgui::ImGui
    {
        self.imgui_handler.imgui_mut()
    }
    
    pub fn goto_constructed_scene(&mut self, next_scene : Box<Scene>)
    {
        self.next_scene = next_scene;
        self.next_scene_waiting = true;
    }
}

struct GameloopTimeState
{
    jiffies : Instant,
    last_jiffies : Instant,
    last_fps_jiffies : Instant,
    jiffy_queue : Duration,
    target_frametime : Duration,
    lag_this_second : u32,
    thought_yet : bool,
    think_timer : GameloopStopwatch,
    draw_timer : GameloopStopwatch,
    wait_timer : GameloopStopwatch,
    present_timer : GameloopStopwatch
}

impl GameloopTimeState
{
    fn new() -> GameloopTimeState
    {
        let jiffies = Instant::now();
        let last_jiffies = jiffies;
        let last_fps_jiffies = Instant::now();
        let jiffy_queue = Duration::new(0, 0);
        let target_frametime = Duration::new(0, 0);
        
        GameloopTimeState
        {
            jiffies,
            last_jiffies,
            last_fps_jiffies,
            jiffy_queue,
            target_frametime,
            lag_this_second : 0,
            thought_yet : false,
            think_timer : GameloopStopwatch::new(),
            draw_timer : GameloopStopwatch::new(),
            wait_timer : GameloopStopwatch::new(),
            present_timer : GameloopStopwatch::new()
        }
    }
    
    fn new_second(&mut self)
    {
        self.think_timer.new_second();
        self.draw_timer.new_second();
        self.wait_timer.new_second();
        self.present_timer.new_second();
        
        self.last_fps_jiffies += Duration::from_secs(1);
        self.lag_this_second = 0;
    }
    
    fn update_jiffies(&mut self)
    {
        self.jiffies = Instant::now();
        self.jiffy_queue += self.jiffies - self.last_jiffies;
        self.last_jiffies = self.jiffies;
    }
    
    fn sleep(&mut self, wait_duration : Duration)
    {
        while self.jiffy_queue <= wait_duration
        {
            self.update_jiffies();
            
            if self.jiffy_queue <= wait_duration - Duration::from_millis(1)
            {
                std::thread::sleep(Duration::from_millis(1));
            }
        }
    }
}

pub struct Gameloop
{
    #[allow(dead_code)] // Only used by the imgui integration feature
    sdl_context : sdl2::Sdl,
    event_pump : sdl2::EventPump,
    control : GameControl,
    current_scene : Box<Scene>,
    time : GameloopTimeState
}

impl Gameloop
{
    pub fn new(package_name : &str, friendly_name : &str) -> Result<Gameloop, InitError>
    {
        #[cfg(feature = "default_logger")]
        {
            let mut logger = doglog::DogLog::new();
            logger.add_package_filter(String::from(package_name));
            
            if let Err(_) = doglog::DogLog::init(logger, log::LevelFilter::Debug)
            {
                eprintln!("Could not initialize default logger.");
            }
        }
        
        info!("🐶 KEESHOND Game Engine 🐶");
        
        // Messagebox panic handler
        #[cfg(feature = "graphical_panic")]
        std::panic::set_hook(Box::new(panic_hook));
        
        // Get commandline options
        let _matches = read_options();
        
        let version = sdl2::version::version();
        info!("Starting SDL version {}", version);
        
        // Subsystems init
        let sdl_context = try_or_else!(sdl2::init(),
            |error| Err(InitError::Sdl2InitError(Sdl2Subsystem::Main, error)));
        let event_pump = try_or_else!(sdl_context.event_pump(),
            |error| Err(InitError::Sdl2InitError(Sdl2Subsystem::Event, error)));
        
        #[allow(unused_mut)] // mut used only by imgui feature
        let mut control = try_or_else!(GameControl::new(Some(&sdl_context)), |error| Err(error));
        
        control.renderer_mut().set_window_title(friendly_name);
        
        Ok(Gameloop
        {
            sdl_context,
            event_pump,
            control,
            current_scene : Box::new(Scene::new()),
            time : GameloopTimeState::new()
        })
    }
    
    pub fn control(&self) -> &GameControl
    {
        &self.control
    }
    
    pub fn control_mut(&mut self) -> &mut GameControl
    {
        &mut self.control
    }
    
    fn update_input(&mut self)
    {
        let event_pump = &self.event_pump;
        
        let mut callback = | key : &str |
        {
            let scancode = try_opt_or_else!(Scancode::from_name(key), || false);
            
            event_pump.keyboard_state().is_scancode_pressed(scancode)
        };
        
        self.control.input_mut().check_and_update_state(&mut callback);
    }
    
    fn think(&mut self)
    {
        self.time.think_timer.begin_frame_timing();
        
        let target_ms = 1000.0 / self.control.target_framerate();
        self.time.target_frametime = Duration::from_nanos((target_ms * 1_000_000.0) as u64);
        
        self.control.sync_audio_store();
        
        while self.time.jiffy_queue > self.time.target_frametime
        {
            // Prevent overflow if CPU cannot process all the frames
            if (self.time.think_timer.jiffies_this_frame()) > self.time.target_frametime
            {
                while self.time.jiffy_queue > self.time.target_frametime
                {
                    self.time.jiffy_queue -= self.time.target_frametime;
                    self.time.lag_this_second += 1;
                }
                break;
            }
            
            self.update_input();
            self.current_scene.think(&mut self.control);
            
            self.time.think_timer.tic();
            
            self.time.jiffy_queue -= self.time.target_frametime;
            self.time.thought_yet = true;
        }
        
        self.time.think_timer.end_frame_timing();
    }
    
    fn draw(&mut self)
    {
        self.time.draw_timer.begin_frame_timing();
        
        if self.time.thought_yet
        {
            let mut interpolation_amount = 0.0;
        
            if self.control.frame_interpolation
            {
                interpolation_amount = (self.time.jiffy_queue.as_nanos() as f64
                    / self.time.target_frametime.as_nanos() as f64) - 1.0;
            }
            
            self.control.renderer.control().sync_sheet_store(&mut self.control.resources.sheet_store)
                .expect("GPU sheet store sync failed");
            self.control.renderer.control().sync_shader_store(&mut self.control.resources.shader_store)
                .expect("GPU shader store sync failed");
            
            self.control.renderer.draw(&mut self.current_scene, interpolation_amount as f32);
        }
        
        #[cfg(feature = "imgui_integration")]
        {
            self.update_imgui();
        }
        
        self.control.renderer.control().flush_drawing();
        
        self.time.draw_timer.end_frame_timing();
    }
    
    #[cfg(feature = "imgui_integration")]
    fn update_imgui(&mut self)
    {
        let frametime = self.time.target_frametime * self.time.think_timer.tics_this_frame();
        self.control.imgui_handler.update_cursor(&mut self.sdl_context.mouse());
        
        let frame_delta = frametime.as_nanos() as f64 * MILLISECONDS_PER_NANOSECOND / 1000.0;
        let (width, height) = self.control.renderer.window_size();
        let mut ui = self.control.imgui_handler.imgui_mut()
            .frame(imgui::FrameSize::new(width as f64, height as f64, 1.0), frame_delta as f32);
        
        self.current_scene.imgui_think(&mut ui);
        
        self.control.renderer.control().draw_imgui(ui);
    }
    
    fn wait(&mut self)
    {
        self.time.wait_timer.begin_frame_timing();
        
        if !self.control.frame_interpolation
        {
            // Spin until it's time for the next frame
            self.time.sleep(self.time.target_frametime);
        }
        else
        {
            self.time.update_jiffies();
        }
        
        self.time.wait_timer.end_frame_timing();
    }
    
    fn present(&mut self)
    {
        self.time.present_timer.begin_frame_timing();
        
        self.control.renderer.present();
        
        self.time.present_timer.end_frame_timing();
    }
    
    fn update_fps(&mut self)
    {
        if self.time.jiffies < self.time.last_fps_jiffies + Duration::from_secs(1)
        {
            return;
        }
        
        debug!("{} ents  |  FPS: {} / {}  |  avg ms:  think {:.2}  draw {:.2}  present {:.2}  wait {:.2}",
        self.current_scene.entity_count(),
            self.time.draw_timer.frames_this_second(),
            self.time.think_timer.tics_this_second(),
            self.time.think_timer.average_ms(),
            self.time.draw_timer.average_ms(),
            self.time.present_timer.average_ms(),
            self.time.wait_timer.average_ms());
        
        if self.time.lag_this_second > 0
        {
            warn!("Too much CPU work, game is slowing down!");
        }
        
        self.time.new_second();
    }

    pub fn run(&mut self)
    {
        self.time = GameloopTimeState::new();
        
        'runloop: loop
        {
            // Consume events
            for event in self.event_pump.poll_iter()
            {
                match event
                {
                    Event::Quit {..} =>
                    {
                        break 'runloop;
                    },
                    Event::Window { win_event, .. } => match win_event
                    {
                        WindowEvent::SizeChanged {..} =>
                        {
                            self.control.renderer.recalculate_viewport();
                        }
                        _ => ()
                    },
                    Event::KeyDown { scancode, keymod, repeat, .. } =>
                    {
                        // For some reason I can't access LALTMOD and RALTMOD
                        //  so I have to use the bitmasks manually...
                        if !repeat && (keymod.contains(KeyboardMod::from_bits_truncate(0x0100))
                            || keymod.contains(KeyboardMod::from_bits_truncate(0x0200)))
                            && scancode == Some(sdl2::keyboard::Scancode::Return)
                        {
                            self.control.renderer.toggle_fullscreen();
                        }
                    },
                    _ => ()
                }
                
                #[cfg(feature = "imgui_integration")]
                self.control.imgui_handler.handle_event(event);
            }
            
            self.think();
            self.draw();
            self.wait();
            self.present();
            
            self.update_fps();
            
            // Go to next scene if one is requested
            if self.control.next_scene_waiting
            {
                std::mem::swap(&mut self.current_scene, &mut self.control.next_scene);
                
                // Reset jiffy queue
                self.time = GameloopTimeState::new();
                self.control.next_scene_waiting = false;
            }
        }
    }
}