#![feature(box_syntax)]
#![feature(fs_try_exists)]
#![feature(if_let_guard)]

pub mod condition;
pub mod demo;
pub mod helper;
pub mod interface;
pub mod savestate;
pub mod schedule;

use chrono::NaiveDateTime;
use condition::ConditionFind;
use crossbeam_channel::Sender;
use helper::Overlaps;
use karlcommon::{ClientboundPacket, ProtoError, Schedule, ServerboundPacket, Task};
use log::{debug, error, info};
use std::{
    collections::HashMap,
    sync::{atomic::AtomicU32, RwLock},
};

use crate::schedule::schedule_dynamic;

fn main() {
    env_logger::init();
    info!("logging");
    if let Err(e) = savestate::load() {
        error!("load failed: {}", e);
    }

    std::thread::spawn(move || {
        std::thread::sleep(std::time::Duration::from_secs_f64(0.1));
        schedule_dynamic();
    });

    interface::start();

    loop {
        std::thread::sleep(std::time::Duration::from_secs_f64(100.0));
    }
}

lazy_static::lazy_static! {
    static ref TASKS: RwLock<HashMap<u64, Task>> = RwLock::new(HashMap::new());
    static ref CLIENT_ID_COUNTER: AtomicU32 = AtomicU32::new(0);
}

pub fn handle_packet(client: u32, packet: ServerboundPacket, responder: Sender<ClientboundPacket>) {
    // std::thread::sleep(std::time::Duration::from_millis(75)); // for testing clients with latency
    match packet {
        ServerboundPacket::Sync => {
            let _ = responder.send(ClientboundPacket::Sync);
        }
        ServerboundPacket::ListTasks => {
            let _ = responder.send(ClientboundPacket::TaskList(
                TASKS.read().unwrap().values().map(|e| e.clone()).collect(),
            ));
        }
        ServerboundPacket::UpdateTask(t) => {
            TASKS.write().unwrap().insert(t.id, t);
            savestate::save();
        }
        ServerboundPacket::RemoveTask(i) => {
            if TASKS.write().unwrap().remove(&i).is_none() {
                let _ = responder.send(ClientboundPacket::Error(ProtoError::UnknownTask));
            }
            savestate::save();
        }
        ServerboundPacket::Handshake { version } => {
            debug!("{client}: version {version}");
        }
        ServerboundPacket::ListInstances { range, task, limit } => {
            let t = match TASKS.read().unwrap().get(&task).cloned() {
                Some(t) => t,
                None => {
                    let _ = responder.send(ClientboundPacket::Error(ProtoError::UnknownTask));
                    return;
                }
            };

            let mut ocs = vec![];
            match t.schedule {
                Schedule::Never => (),
                Schedule::Dynamic { .. } => (), // TODO
                Schedule::Static(r) => {
                    if range.overlaps(r.clone()) {
                        ocs.push(Some(r.start)..Some(r.end))
                    }
                }
                Schedule::Condition(o) => {
                    let mut time = NaiveDateTime::from_timestamp(range.start.unwrap_or(0), 0);
                    let end_time = range.end.map(|e| NaiveDateTime::from_timestamp(e, 0));
                    for _ in 0..limit {
                        let start =
                            o.find(condition::Edge::Start, condition::Direction::Forward, time);
                        let end = o.find(condition::Edge::End, condition::Direction::Forward, time);
                        ocs.push(start.map(|e| e.timestamp())..end.map(|e| e.timestamp()));
                        if let Some(s) = end {
                            if let Some(e) = end_time {
                                if s > e {
                                    break;
                                }
                            }
                            time = s;
                        } else {
                            break;
                        }
                    }
                }
            }
            let _ = responder.send(ClientboundPacket::InstanceList(ocs));
        }
    }
}