use bevy::prelude::*;
use serde_yaml::Value;
use serde::Deserialize;
use crate::{audio, hud, settings, world};

pub const CHATS: &[&str] = &[
    include_str!("chats/serenity.yaml"),
    include_str!("chats/startrans.yaml"),
];

pub const TOKEN_CHAT: &str = "chat";
pub const TOKEN_SYSTEM: &str = "system";
pub const TOKEN_WARN: &str = "warn";
pub const TOKEN_SET: &str = "set";
pub const TOKEN_IF: &str = "if";
pub const TOKEN_GOTO: &str = "goto";
pub const TOKEN_LABEL: &str = "label";
pub const TOKEN_SCRIPT: &str = "script";

pub const NAME_FALLBACK: &str = "Unknown";

pub const CHOICE_TIMER: f64 = 40.0 * settings::DEFAULT_CHAT_SPEED as f64;
pub const LETTERS_PER_SECOND: f32 = 17.0;
pub const TALKER_SPEED_FACTOR: f32 = settings::DEFAULT_CHAT_SPEED / LETTERS_PER_SECOND;
pub const CHAT_SPEED_MIN_LEN: f32 = 40.0;

pub const NON_CHOICE_TOKENS: &[&str] = &[
    TOKEN_CHAT,
    TOKEN_SYSTEM,
    TOKEN_WARN,
    TOKEN_SET,
    TOKEN_IF,
    TOKEN_GOTO,
    TOKEN_LABEL,
    TOKEN_SCRIPT,
];

pub struct ChatPlugin;
impl Plugin for ChatPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(Startup, load_chats);
        app.add_systems(Update, (
            handle_reply_keys.before(handle_chat_timer),
            handle_chat_timer.before(handle_chat_events),
            handle_new_conversations.before(handle_chat_events),
            handle_chat_events,
        ));
        app.add_event::<StartConversationEvent>();
        app.add_event::<ChatEvent>();
        app.insert_resource(ChatDB(Vec::new()));
    }
}

type ChatPos = Vec<usize>;

#[derive(Component)]
pub struct Chat {
    pub id: usize,
    pub position: ChatPos,
    pub timer: f64,
    pub talker: Talker,
}

#[derive(Component)]
pub struct Choice {
    pub text: String,
    pub key: usize,
    pub goto: ChatPos,
}

// This is the only place where any YAML interaction should be happening.
#[derive(Resource)]
pub struct ChatDB(Vec<Value>);
impl ChatDB {
    pub fn load_from_str(&mut self, yaml_string: &str) -> Result<(), ()> {
        let mut count = 0;
        for document in serde_yaml::Deserializer::from_str(yaml_string) {
            match Value::deserialize(document) {
                Ok(yaml_data) => {
                    if let Value::Sequence(yaml_sequence) = yaml_data {
                        self.0.push(Value::Sequence(yaml_sequence));
                        count += 1;
                    }
                    else {
                        error!("Could not load YAML: {:?}", yaml_data);
                    }
                }
                Err(error) => {
                    dbg!(error);
                    return Err(());
                }
            }
        }
        info!("Loaded {count} conversations");
        return Ok(());
    }

    pub fn get_chat_by_id(&self, id: &String) -> Result<usize, String> {
        let mut found: Option<usize> = None;
        for (index, object_yaml) in self.0.iter().enumerate() {
            if let Some(chat_id) = object_yaml[0][TOKEN_CHAT].as_str() {
                if chat_id == id {
                    if found.is_some() {
                        return Err("Found multiple chats with the same id!".to_string());
                    }
                    found = Some(index);
                }
            }
        }
        if let Some(result) = found {
            return Ok(result);
        }
        return Err(format!("No chat with the conversation ID `{id}` was found."));
    }

    fn search_choice(&self, yaml: Option<&Value>) -> Option<String> {
        let non_choice_tokens = NON_CHOICE_TOKENS.to_vec();
        if let Some(Value::Mapping(hash)) = yaml {
            for key in hash.keys() {
                if let Value::String(key) = key {
                    if non_choice_tokens.contains(&key.as_str()) {
                        continue;
                    }
                    return Some(key.into());
                }
            }
        }
        return None;
    }

    // returns false if the advanced pointer is out of bounds
    fn advance_pointer(&self, chat: &mut Chat) -> bool {
        let index = chat.position.len() - 1;
        chat.position[index] += 1;

        while chat.position.len() > 0 {
            dbg!(self.at(chat.id, &chat.position));
            match self.at(chat.id, &chat.position) {
                None => {
                    dbg!("Pop.");
                    chat.position.pop();
                    let index = chat.position.len() - 1;
                    chat.position[index] += 1;
                },
                Some(_) => {
                    break;
                }
            }
        }
        return true;
    }

    // Note that this (intentionally) may result in a pointer that's out of bounds.
    fn pointer_lookahead(&self, position: &mut Vec<usize>) {
        let index = position.len() - 1;
        position[index] += 1;
    }

    fn at(&self, id: usize, position: &Vec<usize>) -> Option<&Value> {
        if position.len() == 0 {
            return None;
        }
        let mut pointer: Option<&Value> = Some(&self.0[id]);
        for index in position {
            if let Some(Value::Sequence(seq)) = self.0.get(id) {
                // TODO: handle mappings
                if let Some(value) = seq.get(*index) {
                    pointer = Some(value);
                }
            } else {
                return None;
            }
        }
        return pointer;
    }

    pub fn advance_chat(&self, chat: &mut Chat, event: &mut EventWriter<ChatEvent>) {
        event.send(ChatEvent::DespawnAllChoices);
        let conv = &self.0.get(chat.id);
        if conv.is_none() {
            return;
        }

        // Handle next entry in the chat list
        let mut is_skipping_through = false;
        if !self.advance_pointer(chat) {
            event.send(ChatEvent::SpawnMessage("Disconnected.".to_string()));
            event.send(ChatEvent::DespawnAllChats);
            return;
        }
        else if let Some(_) = self.search_choice(self.at(chat.id, &chat.position)) {
            is_skipping_through = true;
        }
        else if let Some(Value::String(message)) = self.at(chat.id, &chat.position) {
            event.send(ChatEvent::SpawnMessage(message.to_string()));
        }

        // Check if the immediately following entries are choices
        let mut pos = chat.position.clone();
        self.pointer_lookahead(&mut pos);
        let mut key: usize = 0;
        loop {
            if is_skipping_through /*|| pos[0] >= conv.len()*/ {  // TODO: out of bounds checking
                break;
            }
            if let Some(choice) = self.search_choice(self.at(chat.id, &pos)) {
                let mut goto: Vec<usize> = pos.clone();
                goto.push(0);
                event.send(ChatEvent::SpawnChoice(choice, key, goto));
                key += 1;
            }
            else {
                break;
            }
            self.pointer_lookahead(&mut pos);
        }
    }
}

#[derive(Component)]
#[derive(Clone)]
pub struct Talker {
    pub conv_id: String,
    pub name: Option<String>,
    pub pronoun: Option<String>,
    pub talking_speed: f32,
}

#[derive(Event)]
pub struct StartConversationEvent {
    pub talker: Talker,
}

#[derive(Event)]
pub enum ChatEvent {
    DespawnAllChoices,
    DespawnAllChats,
    SpawnMessage(String),
    SpawnChoice(String, usize, ChatPos),
    //Script(String, String, String),
}

pub fn load_chats(mut chatdb: ResMut<ChatDB>) {
    for chat_yaml in CHATS {
        if chatdb.load_from_str(chat_yaml).is_err() {
            error!("Could not load chat definitions.  Validate files in `src/chats/` path.");
        }
    }
}

pub fn handle_new_conversations(
    mut commands: Commands,
    mut er_conv: EventReader<StartConversationEvent>,
    mut ew_sfx: EventWriter<audio::PlaySfxEvent>,
    mut ew_chatevent: EventWriter<ChatEvent>,
    chatdb: Res<ChatDB>,
    q_chats: Query<&Chat>,
    time: Res<Time>,
) {
    for event in er_conv.read() {
        if !q_chats.is_empty() {
            ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Ping));
            return;
        }
        match (*chatdb).get_chat_by_id(&event.talker.conv_id) {
            Ok(chat_id) => {
                ew_sfx.send(audio::PlaySfxEvent(audio::Sfx::Ping));
                let mut chat = Chat {
                    id: chat_id,
                    position: vec![0],
                    timer: time.elapsed_seconds_f64(),
                    talker: event.talker.clone(),
                };
                chatdb.advance_chat(&mut chat, &mut ew_chatevent);
                commands.spawn((
                    chat,
                    world::DespawnOnPlayerDeath,
                ));
            }
            Err(error) => {
                error!("Error while looking for chat ID: {error}");
            }
        }
    }
}

pub fn handle_chat_timer(
    time: Res<Time>,
    chatdb: Res<ChatDB>,
    mut q_chats: Query<&mut Chat>,
    mut ew_chatevent: EventWriter<ChatEvent>,
) {
    let now = time.elapsed_seconds_f64();
    for mut chat in &mut q_chats {
        if now >= chat.timer {
            chatdb.advance_chat(&mut chat, &mut ew_chatevent);
        }
    }
}

pub fn handle_chat_events(
    mut commands: Commands,
    mut er_chatevent: EventReader<ChatEvent>,
    mut log: ResMut<hud::Log>,
    q_choices: Query<Entity, With<Choice>>,
    mut q_chats: Query<(Entity, &mut Chat)>,
    time: Res<Time>,
    settings: Res<settings::Settings>,
) {
    for event in er_chatevent.read() {
        let now = time.elapsed_seconds_f64();
        let chat_maybe = q_chats.get_single_mut();
        if chat_maybe.is_err() {
            return;
        }
        let (chat_entity, mut chat) = chat_maybe.unwrap();

        match event {
            ChatEvent::DespawnAllChoices => {
                for entity in &q_choices {
                    commands.entity(entity).despawn();
                }
            }
            ChatEvent::DespawnAllChats => {
                commands.entity(chat_entity).despawn();
            }
            ChatEvent::SpawnMessage(message) => {
                log.chat(message.into(), chat.talker.name.clone().unwrap_or(NAME_FALLBACK.to_string()));
                chat.timer = now + ((message.len() as f32).max(CHAT_SPEED_MIN_LEN) * TALKER_SPEED_FACTOR * chat.talker.talking_speed / settings.chat_speed) as f64;
            }
            ChatEvent::SpawnChoice(replytext, key, goto) => {
                commands.spawn((
                    world::DespawnOnPlayerDeath,
                    Choice {
                        text: replytext.into(),
                        key: *key,
                        goto: goto.clone(),
                    }
                ));
                chat.timer = now + CHOICE_TIMER / settings.chat_speed as f64;
            }
        }
    }
}

fn handle_reply_keys(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    settings: ResMut<settings::Settings>,
    q_choices: Query<&Choice>,
    mut q_chats: Query<&mut Chat>,
    //mut evwriter_sendmsg: EventWriter<SendMessageEvent>,
    mut evwriter_sfx: EventWriter<audio::PlaySfxEvent>,
    time: Res<Time>,
) {
    let mut selected_choice: usize = 0;
    'outer: for key in settings.get_reply_keys() {
        if keyboard_input.just_pressed(key) {
            for choice in &q_choices {
                if choice.key == selected_choice {
                    if let Ok(mut chat) = q_chats.get_single_mut() {
                        evwriter_sfx.send(audio::PlaySfxEvent(audio::Sfx::Click));
                        chat.timer = time.elapsed_seconds_f64();
                        chat.position = choice.goto.clone();
                        info!("GOTO {:?}", &chat.position);
                    }
                    break 'outer;
                }
            }
        }
        selected_choice += 1;
    }
}