pub mod condition;
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 interface::network_loop;
use karlcommon::{
    ClientboundPacket, Condition, Property, ProtoError, Schedule, ServerboundPacket, Task,
};
use log::{debug, error, info};
use std::{collections::HashMap, sync::RwLock};

fn main() {
    env_logger::init();
    info!("logging");
    if let Err(e) = savestate::load() {
        error!("load failed: {}", e);
    }
    TASKS.write().unwrap().insert(
        0,
        Task {
            id: 0,
            name: "Mittagessen im Februar".to_string(),
            description: None,
            tags: vec!["Essen".to_string(), "Unwichtig".to_string()],
            schedule: Schedule::Condition(Condition::And(vec![
                Condition::Equal {
                    modulus: None,
                    prop: Property::Monthofyear,
                    value: 1,
                },
                Condition::Equal {
                    modulus: None,
                    prop: Property::Hour,
                    value: 12,
                },
            ])),
        },
    );
    TASKS.write().unwrap().insert(
        1,
        Task {
            id: 1,
            name: "Abendessen oder Frühstück".to_string(),
            description: Some("Nom nom nom".to_string()),
            tags: vec!["Essen".to_string()],
            schedule: Schedule::Condition(Condition::Or(vec![
                Condition::Equal {
                    modulus: None,
                    prop: Property::Hour,
                    value: 18,
                },
                Condition::Equal {
                    modulus: None,
                    prop: Property::Hour,
                    value: 7,
                },
            ])),
        },
    );
    TASKS.write().unwrap().insert(
        2,
        Task {
            id: 2,
            description: None,
            name: "Wichtiger termin™".to_string(),
            tags: vec![],
            schedule: Schedule::Static(1654997366..1655007366),
        },
    );
    network_loop();
}

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

pub fn handle_packet(client: u32, packet: ServerboundPacket, responder: Sender<ClientboundPacket>) {
    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));
        }
    }
}