use std::env;

use chrono::{DateTime, Local, SecondsFormat};

use fltk::{app, button, frame, prelude::*, text, window::Window};

use tokio::{
    fs,
    io::AsyncWriteExt,
    time::{interval_at, Duration},
};

mod config;
mod error;
mod offset;

use config::Config;
use error::Error;

#[tokio::main]
async fn main() -> Result<(), Error> {
    let config = Config::from_args(env::args())?;

    let (fltk_tx, fltk_rx) = app::channel::<Message>();

    let app = app::App::default();

    tokio::spawn(async move {
        let mut i = interval_at(
            offset::get_next_tick(config.interval_secs, config.offset_secs).into(),
            Duration::from_secs(config.interval_secs),
        );
        i.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);

        loop {
            i.tick().await;
            eprintln!("3SAHNQ43 Popping up");
            fltk_tx.send(Message::PopUp);
        }
    });

    let mut gui = Gui::new(config, fltk_tx);

    while app.wait() {
        let msg = match fltk_rx.recv() {
            Some(x) => x,
            None => continue,
        };

        match msg {
            Message::Submit => {
                if let Err(e) = gui.submit().await {
                    eprintln!("DVW4SBNB Error while submitting: {:?}", e);
                }
            }
            Message::PopUp => {
                if let Err(e) = gui.pop_up() {
                    eprintln!("5BWNNQT6 Error while popping up: {:?}", e);
                }
            }
        }
    }

    Ok(())
}

#[derive(Clone, Copy)]
enum Message {
    PopUp,
    Submit,
}

#[derive(serde::Serialize)]
struct JournalLine {
    text: String,
    time_popped_up: Option<String>,
    time_submitted: String,
}

struct Gui {
    time_popped_up: Option<DateTime<Local>>,
    editor: text::TextEditor,
    status: frame::Frame,
    wind: Window,
}

impl Gui {
    fn new(config: Config, fltk_tx: app::Sender<Message>) -> Self {
        let mut wind = Window::new(100, 100, 640, 480, "Annoying Journal");
        wind.make_resizable(true);

        let mut buffer = text::TextBuffer::default();
        buffer.set_text(&config.prompt);
        let mut display = text::TextDisplay::new(0, 0, 640, 50, "");
        display.set_buffer(Some(buffer));

        let mut editor = text::TextEditor::new(0, 50, 640, 480 - 50 - 50, "");
        editor.set_buffer(Some(text::TextBuffer::default()));

        editor.set_tab_nav(true);

        let mut but = button::ReturnButton::new(640 - 100, 480 - 50, 100, 50, "Submit");
        but.emit(fltk_tx, Message::Submit);

        let status = frame::Frame::new(0, 480 - 50, 640 - 100, 50, "");

        wind.set_label("ANNOYING JOURNAL");
        wind.end();
        wind.show();

        let mut that = Self {
            time_popped_up: Some(Local::now()),
            editor,
            status,
            wind,
        };

        that.refresh_status();

        that
    }

    fn refresh_status(&mut self) {
        let version = option_env!("CARGO_PKG_VERSION").unwrap_or("(???)");
        let time_popped_up = self
            .time_popped_up
            .map(|x| x.to_rfc3339_opts(SecondsFormat::Secs, true))
            .unwrap_or_else(|| "(???)".to_string());

        self.status
            .set_label(&format!("v{}, popped up at {}", version, time_popped_up));
    }

    fn pop_up(&mut self) -> Result<(), Error> {
        if self.time_popped_up.is_some() {
            eprintln!("O4U6E36V Ignoring pop-up, already popped up");
            return Ok(());
        }

        self.time_popped_up = Some(Local::now());
        self.refresh_status();
        self.wind.set_label("ANNOYING JOURNAL");
        self.wind.show();
        self.editor.take_focus()?;

        Ok(())
    }

    async fn submit(&mut self) -> Result<(), Error> {
        let buffer = match self.editor.buffer() {
            None => return Err(Error::EditorHasNoBuffer),
            Some(x) => x,
        };

        let jl = JournalLine {
            text: buffer.text(),
            time_popped_up: self
                .time_popped_up
                .map(|x| x.to_rfc3339_opts(SecondsFormat::Secs, true)),
            time_submitted: Local::now().to_rfc3339_opts(SecondsFormat::Secs, true),
        };

        let s = serde_json::to_string(&jl)?;

        fs::create_dir_all("annoying_journal").await?;

        let mut f = fs::OpenOptions::new()
            .append(true)
            .create(true)
            .open("annoying_journal/journal.jsonl")
            .await?;
        f.write_all(s.as_bytes()).await?;
        f.write_all(b"\n").await?;

        println!("{}", s);
        self.editor.set_buffer(text::TextBuffer::default());
        self.wind.iconize();
        self.time_popped_up = None;
        self.wind.set_label("annoying journal");

        Ok(())
    }
}