use std::sync::Arc;

use crossterm::event::{Event, self, KeyCode};
use tokio;

use log::warn;

use crate::db::DB;
use crate::db::data_cache::DataCache;
use crate::uis::history::HistoryState;
use crate::uis::new_transaction::NewTransactionTabState;
use crate::uis::navigation_frame::NavigationState;

pub type AppResult<T> = std::result::Result<T, Box<dyn std::error::Error>>;

pub enum InputMode {
    Insert,
    Normal,
}

pub struct App<'a> {
    pub running: bool,

    pub states: States<'a>,

    pub input_mode: InputMode,

    pub db: Arc<tokio::sync::Mutex<DB>>,
    pub data_cache: DataCache,
}

impl<'a> App<'a> {
    pub fn new(db: DB, data_cache: DataCache) -> App<'a> {
        App {
            running: true,
            states: States::new(),
            input_mode: InputMode::Normal,
            db: Arc::new(tokio::sync::Mutex::new(db)),
            data_cache,
        }
    }

    pub fn poll_events(&mut self) -> AppResult<()> {
        if let Event::Key(key) = event::read()? {
            // 'q' needs to be handled at the top level so it can't be
            // accidentally handed to a dead end
            if let KeyCode::Char('q') = key.code {
                if let Some(_) = self.states.nav_state.message.clone() {
                    self.states.nav_state.message = None;
                } else {
                    if let ActiveFrame::Navigation = self.states.active_frame {
                        self.running = false;
                    } else {
                        self.states.active_frame = ActiveFrame::Navigation;
                    }
                }
            } else if let KeyCode::Esc = key.code {
                if let Some(_) = self.states.nav_state.message.clone() {
                    self.states.nav_state.message = None;
                } else {
                    if let ActiveFrame::Navigation = self.states.active_frame {
                        self.running = false;
                    } else {
                        self.states.active_frame = ActiveFrame::Navigation;
                    }
                }
            }
            if let KeyCode::Char('r') = key.code {
                self.refresh();
            }
            match self.states.active_frame {
                ActiveFrame::Navigation => {
                    NavigationState::handle_event(key, self);
                }
                ActiveFrame::History => {
                    HistoryState::handle_event(key, self);
                }
                ActiveFrame::NewTransaction => {
                    NewTransactionTabState::handle_event(key, self);
                }
            }
        }
        return Ok(())
    }

    pub fn refresh(&mut self) {

        let fut = Arc::clone(&self.db);
        
        tokio::spawn(async move { 
            let res = fut.lock().await.get_all_records().await;
            match res {
                Ok(_) => {},
                Err(e) => warn!("{}", e)
            }
        });

    }
}

pub enum ActiveFrame {
    Navigation,
    NewTransaction,
    History,
}

pub struct States<'a> {
    pub nav_state: NavigationState<'a>,
    pub transactions: NewTransactionTabState<'a>,
    pub history: HistoryState,

    pub active_frame: ActiveFrame,
}

impl<'a> States<'a> {
    pub fn new() -> States<'a> {
        States {
            nav_state: NavigationState::new(),
            transactions: NewTransactionTabState::new(),
            history: HistoryState::new(),

            active_frame: ActiveFrame::Navigation,
        }
    }
}