use std::{
    collections::{hash_map::DefaultHasher, HashSet},
    hash::{Hash, Hasher},
};

use chrono::{DateTime, Datelike, Duration, Local, Utc};
use itertools::Itertools;
use log::{error, info};
use seed::{prelude::*, *};
use seed_hooks::{
    state_access::{CloneState, StateAccess},
    topo, use_state,
};
use wasm_timer::Instant;

use crate::{
    api::urls,
    consts::{SEARCH_RESULTS_PER_PAGE, USE_GRAPHQL},
    graphql::{front_page_query::*, show_thread_query::*},
    state::{Model, Msg, RefreshingState},
};

mod desktop;
mod legacy;
mod mobile;
mod tablet;

const MAX_RAW_MESSAGE_SIZE: usize = 100_000;
fn set_title(title: &str) {
    seed::document().set_title(&format!("lb: {}", title));
}

fn tags_chiclet(tags: &[String], is_mobile: bool) -> impl Iterator<Item = Node<Msg>> + '_ {
    tags.iter().map(move |tag| {
        let mut hasher = DefaultHasher::new();
        tag.hash(&mut hasher);
        let hex = format!("#{:06x}", hasher.finish() % (1 << 24));
        let style = style! {St::BackgroundColor=>hex};
        let classes = C!["tag", IF!(is_mobile => "is-small")];
        let tag = tag.clone();
        a![
            attrs! {
                At::Href => urls::search(&format!("tag:{tag}"), 0)
            },
            match tag.as_str() {
                "attachment" => span![classes, style, "📎"],
                "replied" => span![classes, style, i![C!["fa-solid", "fa-reply"]]],
                _ => span![classes, style, &tag],
            },
            ev(Ev::Click, move |_| Msg::SearchRequest {
                query: format!("tag:{tag}"),
                page: 0,
                results_per_page: SEARCH_RESULTS_PER_PAGE,
            })
        ]
    })
}

fn pretty_authors(authors: &str) -> impl Iterator<Item = Node<Msg>> + '_ {
    let one_person = authors.matches(',').count() == 0;
    let authors = authors.split(',');

    Itertools::intersperse(
        authors.filter_map(move |author| {
            if one_person {
                return Some(span![
                    attrs! {
                    At::Title => author.trim()},
                    author
                ]);
            }
            author.split_whitespace().nth(0).map(|first| {
                span![
                    attrs! {
                    At::Title => author.trim()},
                    first
                ]
            })
        }),
        span![", "],
    )
}

fn human_age(timestamp: i64) -> String {
    let now = Local::now();
    let yesterday = now - Duration::days(1);
    let ts = DateTime::<Utc>::from_timestamp(timestamp, 0)
        .unwrap()
        .with_timezone(&Local);
    let age = now - ts;
    let datetime = if age < Duration::minutes(1) {
        format!("{} min. ago", age.num_seconds())
    } else if age < Duration::hours(1) {
        format!("{} min. ago", age.num_minutes())
    } else if ts.date_naive() == now.date_naive() {
        ts.format("Today %H:%M").to_string()
    } else if ts.date_naive() == yesterday.date_naive() {
        ts.format("Yest. %H:%M").to_string()
    } else if age < Duration::weeks(1) {
        ts.format("%a %H:%M").to_string()
    } else if ts.year() == now.year() {
        ts.format("%b %d %H:%M").to_string()
    } else {
        ts.format("%b %d, %Y %H:%M").to_string()
    };
    datetime
}

fn view_search_results(
    query: &str,
    results: &[FrontPageQuerySearchNodes],
    count: usize,
    pager: &FrontPageQuerySearchPageInfo,
) -> Node<Msg> {
    info!("pager {pager:?}");
    if query.is_empty() {
        set_title("all mail");
    } else {
        set_title(query);
    }
    let rows = results.iter().map(|r| {
        let tid = r.thread.clone();
        let datetime = human_age(r.timestamp as i64);
        tr![
            td![
                C!["from"],
                pretty_authors(&r.authors),
                IF!(r.total>1 => small![" ", r.total.to_string()]),
            ],
            td![
                C!["subject"],
                tags_chiclet(&r.tags, false),
                " ",
                a![
                    C!["has-text-light"],
                    attrs! {
                        At::Href => urls::thread(&tid)
                    },
                    &r.subject,
                ]
            ],
            td![C!["date"], datetime]
        ]
    });

    div![
        view_search_pager(count, pager),
        table![
            C![
                "table",
                "index",
                "is-fullwidth",
                "is-hoverable",
                "is-narrow",
                "is-striped",
            ],
            thead![tr![
                th![C!["from"], "From"],
                th![C!["subject"], "Subject"],
                th![C!["date"], "Date"]
            ]],
            tbody![rows]
        ],
        view_search_pager(count, pager)
    ]
}

fn view_search_pager(count: usize, pager: &FrontPageQuerySearchPageInfo) -> Node<Msg> {
    let start = pager
        .start_cursor
        .as_ref()
        .map(|i| i.parse().unwrap_or(0))
        .unwrap_or(0);
    nav![
        C!["pagination"],
        a![
            C![
                "pagination-previous",
                "button",
                //IF!(!pager.has_previous_page => "is-static"),
            ],
            IF!(!pager.has_previous_page => attrs!{ At::Disabled=>true }),
            "<",
            IF!(pager.has_previous_page => ev(Ev::Click, |_| Msg::PreviousPage)),
        ],
        a![
            C![
                "pagination-next",
                "button",
                //IF!(!pager.has_next_page => "is-static")
            ],
            IF!(!pager.has_next_page => attrs!{ At::Disabled=>true }),
            ">",
            IF!(pager.has_next_page => ev(Ev::Click, |_| Msg::NextPage))
        ],
        ul![
            C!["pagination-list"],
            li![format!(
                "{} - {} of {}",
                start,
                count.min(start + SEARCH_RESULTS_PER_PAGE),
                count
            )],
        ],
    ]
}

trait Email {
    fn name(&self) -> Option<&str>;
    fn addr(&self) -> Option<&str>;
}

impl<T: Email> Email for &'_ T {
    fn name(&self) -> Option<&str> {
        return (*self).name();
    }
    fn addr(&self) -> Option<&str> {
        return (*self).addr();
    }
}

macro_rules! implement_email {
    ( $($t:ty),+ ) => {$(
        impl Email for $t {
            fn name(&self) -> Option<&str> {
                self.name.as_deref()
            }
            fn addr(&self) -> Option<&str> {
                self.addr.as_deref()
            }
        }
    )+};
}

implement_email!(
    ShowThreadQueryThreadMessagesTo,
    ShowThreadQueryThreadMessagesCc,
    ShowThreadQueryThreadMessagesFrom
);

fn view_address(email: impl Email) -> Node<Msg> {
    span![
        C!["tag", "is-black"],
        email.addr().as_ref().map(|a| attrs! {At::Title=>a}),
        email
            .name()
            .as_ref()
            .unwrap_or(&email.addr().unwrap_or("(UNKNOWN)"))
    ]
}

fn view_addresses(addrs: &[impl Email]) -> Vec<Node<Msg>> {
    addrs.into_iter().map(view_address).collect::<Vec<_>>()
}

fn raw_text_message(contents: &str) -> Node<Msg> {
    let (contents, truncated_msg) = if contents.len() > MAX_RAW_MESSAGE_SIZE {
        (
            &contents[..MAX_RAW_MESSAGE_SIZE],
            Some(div!["... contents truncated"]),
        )
    } else {
        (contents, None)
    };
    div![C!["view-part-text-plain"], contents, truncated_msg,]
}

fn has_unread(tags: &[String]) -> bool {
    for t in tags {
        if t == "unread" {
            return true;
        }
    }
    false
}

fn read_message_render(msg: &ShowThreadQueryThreadMessages, open: StateAccess<bool>) -> Node<Msg> {
    let id = msg.id.clone();
    let is_unread = has_unread(&msg.tags);
    div![
        C!["message"],
        div![
            C!["headers"],
            span![
                C!["read-status"],
                i![
                    style! {
                        St::Color => "gold"
                    },
                    C![if is_unread { "fa-regular" } else { "fa-solid" }, "fa-star"],
                    ev(Ev::Click, move |e| {
                        e.stop_propagation();
                        Msg::SetUnread(format!("id:{id}"), !is_unread)
                    }),
                ],
            ],
            " ",
            msg.from
                .as_ref()
                .map(|from| span![C!["header"], view_address(&from)]),
            " ",
            msg.timestamp.map(|ts| span![C!["header"], human_age(ts)]),
            // TODO(wathiede): add first line of message body
        ],
        ev(Ev::Click, move |e| {
            open.set(!open.get());
            e.stop_propagation();
        }),
    ]
}
fn unread_message_render(
    msg: &ShowThreadQueryThreadMessages,
    open: StateAccess<bool>,
) -> Node<Msg> {
    let id = msg.id.clone();
    let is_unread = has_unread(&msg.tags);
    div![
        C!["message"],
        div![
            C!["headers"],
            span![
                C!["read-status"],
                i![
                    style! {
                        St::Color => "gold"
                    },
                    C![if is_unread { "fa-regular" } else { "fa-solid" }, "fa-star"],
                    ev(Ev::Click, move |e| {
                        e.stop_propagation();
                        Msg::SetUnread(format!("id:{id}"), !is_unread)
                    }),
                ],
            ],
            msg.from
                .as_ref()
                .map(|from| div![C!["header"], "From: ", view_address(&from)]),
            msg.timestamp
                .map(|ts| div![C!["header"], "Date: ", human_age(ts)]),
            div![C!["header"], "Message-ID: ", &msg.id],
            div![
                C!["header"],
                IF!(!msg.to.is_empty() => span!["To: ", view_addresses(&msg.to)]),
                IF!(!msg.cc.is_empty() =>  span!["CC: ", view_addresses(&msg.cc)])
            ],
            ev(Ev::Click, move |e| {
                open.set(!open.get());
                e.stop_propagation();
            }),
        ],
        div![
            C!["body"],
            match &msg.body {
                ShowThreadQueryThreadMessagesBody::UnhandledContentType(
                    ShowThreadQueryThreadMessagesBodyOnUnhandledContentType { contents },
                ) => pre![C!["error"], contents],
                ShowThreadQueryThreadMessagesBody::PlainText(
                    ShowThreadQueryThreadMessagesBodyOnPlainText {
                        contents,
                        content_tree,
                    },
                ) => div![
                    raw_text_message(&contents),
                    view_content_tree(&content_tree),
                ],
                ShowThreadQueryThreadMessagesBody::Html(
                    ShowThreadQueryThreadMessagesBodyOnHtml {
                        contents,
                        content_tree,
                    },
                ) => div![
                    C!["view-part-text-html"],
                    raw![contents],
                    IF!(!msg.attachments.is_empty() =>
                    div![
                    C!["attachments"],
                    br![],
                    h2!["Attachments"],
                    msg.attachments
                    .iter()
                    .map(|a| div!["Filename: ", &a.filename, " ", &a.content_type])
                    ]),
                    view_content_tree(&content_tree),
                ],
            }
        ],
    ]
}

#[topo::nested]
fn thread(thread: &ShowThreadQueryThread) -> Node<Msg> {
    // TODO(wathiede): show per-message subject if it changes significantly from top-level subject
    set_title(&thread.subject);
    let mut tags: Vec<_> = thread
        .messages
        .iter()
        .fold(HashSet::new(), |mut tags, msg| {
            tags.extend(msg.tags.clone());
            tags
        })
        .into_iter()
        .collect();
    tags.sort();
    let messages = thread.messages.iter().map(|msg| {
        let is_unread = has_unread(&msg.tags);
        let open = use_state(|| is_unread);
        //info!("open {} {}", open.get(), msg.id);
        if open.get() {
            unread_message_render(&msg, open)
        } else {
            read_message_render(&msg, open)
        }
    });
    let any_unread = thread.messages.iter().any(|msg| has_unread(&msg.tags));
    let thread_id = thread.thread_id.clone();
    div![
        C!["thread"],
        h1![
            C!["title"],
            span![
                C!["read-status"],
                i![
                    style! {
                        St::Color => "gold"
                    },
                    C![
                        if any_unread { "fa-regular" } else { "fa-solid" },
                        "fa-star"
                    ],
                    ev(Ev::Click, move |_| Msg::SetUnread(
                        format!("thread:{}", thread_id),
                        !any_unread
                    )),
                ],
                " ",
            ],
            &thread.subject,
            " ",
            tags_chiclet(&tags, false)
        ],
        messages,
        /* TODO(wathiede): plumb in orignal id
        a![
        attrs! {At::Href=>api::original(&thread_node.0.as_ref().expect("message missing").id)},
        "Original"
        ],
        */
    ]
}

#[topo::nested]
fn view_content_tree(content_tree: &str) -> Node<Msg> {
    let debug_open = use_state(|| false);
    div![
        hr![],
        small![
            i![C![
                "fa-solid",
                if debug_open.get() {
                    "fa-angle-up"
                } else {
                    "fa-angle-down"
                }
            ]],
            " Debug",
            ev(Ev::Click, move |_| {
                debug_open.set(!debug_open.get());
            })
        ],
        IF!(debug_open.get() =>
            pre![C!["content-tree"], content_tree]),
    ]
}

fn view_header(query: &str, refresh_request: &RefreshingState) -> Node<Msg> {
    let is_loading = refresh_request == &RefreshingState::Loading;
    let is_error = if let RefreshingState::Error(err) = refresh_request {
        error!("Failed to refresh: {err:?}");
        true
    } else {
        false
    };
    let query = Url::decode_uri_component(query).unwrap_or("".to_string());
    nav![
        C!["navbar"],
        attrs! {At::Role=>"navigation"},
        div![
            C!["navbar-start"],
            a![
                C!["navbar-item", "button", IF![is_error => "is-danger"]],
                span![i![C![
                    "fa-solid",
                    "fa-arrow-rotate-right",
                    "refresh",
                    IF![is_loading => "loading"],
                ]]],
                ev(Ev::Click, |_| Msg::RefreshStart),
            ],
            a![
                C!["navbar-item", "button"],
                attrs! {
                    At::Href => urls::search("is:unread", 0)
                },
                "Unread",
            ],
            a![
                C!["navbar-item", "button"],
                attrs! {
                    At::Href => urls::search("", 0)
                },
                "All",
            ],
            input![
                C!["navbar-item", "input"],
                attrs! {
                    At::Placeholder => "Search";
                    At::AutoFocus => true.as_at_value();
                    At::Value => query,
                },
                input_ev(Ev::Input, |q| if USE_GRAPHQL {
                    Msg::UpdateQuery(q)
                } else {
                    Msg::SearchRequest {
                        query: Url::encode_uri_component(if q.is_empty() {
                            "*".to_string()
                        } else {
                            q
                        }),
                        page: 0,
                        results_per_page: SEARCH_RESULTS_PER_PAGE,
                    }
                }),
                // Send search on enter.
                keyboard_ev(Ev::KeyUp, move |e| if e.key_code() == 0x0d {
                    if USE_GRAPHQL {
                        Msg::SearchQuery(query)
                    } else {
                        Msg::SearchRequest {
                            query: Url::encode_uri_component(query),
                            page: 0,
                            results_per_page: SEARCH_RESULTS_PER_PAGE,
                        }
                    }
                } else {
                    Msg::Noop
                }),
            ]
        ]
    ]
}

fn view_footer(render_time_ms: u128) -> Node<Msg> {
    footer![
        C!["lb-footer"],
        div![
            C!["content", "has-text-right", "is-size-7"],
            format!("Render time {} ms", render_time_ms)
        ]
    ]
}

// `view` describes what to display.
pub fn view(model: &Model) -> Node<Msg> {
    let start = Instant::now();
    info!("refreshing {:?}", model.refreshing_state);
    let win = seed::window();
    let w = win
        .inner_width()
        .expect("window width")
        .as_f64()
        .expect("window width f64");
    let h = win
        .inner_height()
        .expect("window height")
        .as_f64()
        .expect("window height f64");
    div![
        match w {
            w if w < 800. => div![C!["mobile"], mobile::view(model)],
            w if w < 1024. => div![C!["tablet"], tablet::view(model)],
            _ => div![C!["desktop"], desktop::view(model)],
        },
        view_footer(start.elapsed().as_millis()),
    ]
}