use radicle_tui::ui::widget::{self, Widget};

        let global = ui::widget::common::global_listener().to_boxed();

        let navigation = widget::home::navigation(theme).to_boxed();

        let dashboard = widget::home::dashboard(theme, &context.id, &context.project).to_boxed();

        let issue_browser = widget::home::issues(theme).to_boxed();

        let patch_browser =

            widget::home::patches(theme, &context.patches, &context.profile).to_boxed();

            let navigation = widget::patch::navigation(theme).to_boxed();

            let activity =

                widget::patch::activity(theme, (*id, patch), &context.profile).to_boxed();

            let files = widget::patch::files(theme, (*id, patch), &context.profile).to_boxed();

            Event::WindowResize(_, _) => Some(Message::Tick),

    vec![

        Sub::new(

            SubEventClause::Keyboard(KeyEvent {

                code: Key::Char('q'),

                modifiers: KeyModifiers::NONE,

            }),

            SubClause::Always,

        ),

        Sub::new(SubEventClause::WindowResize, SubClause::Always),

    ]

pub mod common;

pub mod home;

pub mod patch;

use radicle::Profile;

use tuirealm::props::{AttrValue, Attribute};

use tuirealm::MockComponent;

use crate::ui::components::container::{GlobalListener, LabeledContainer, Tabs};

use crate::ui::components::context::{Shortcut, Shortcuts};

use crate::ui::components::label::Label;

use crate::ui::components::list::{Property, PropertyList};

use super::Widget;

use crate::ui::components::list::{List, Table};

use crate::ui::theme::Theme;

pub fn global_listener() -> Widget<GlobalListener> {

    Widget::new(GlobalListener::default())

}

pub fn label(content: &str) -> Widget<Label> {

    // TODO: Remove when size constraints are implemented

    let width = content.chars().count() as u16;

    Widget::new(Label::default())

        .content(AttrValue::String(content.to_string()))

        .height(1)

        .width(width)

}

pub fn labeled_container(

    theme: &Theme,

    title: &str,

    component: Box<dyn MockComponent>,

) -> Widget<LabeledContainer> {

    let title = label(&format!(" {title} "))

        .foreground(theme.colors.default_fg)

        .background(theme.colors.labeled_container_bg);

    let container = LabeledContainer::new(title, component);

    Widget::new(container).background(theme.colors.labeled_container_bg)

}

pub fn shortcut(theme: &Theme, short: &str, long: &str) -> Widget<Shortcut> {

    let short = label(short).foreground(theme.colors.shortcut_short_fg);

    let divider = label(&theme.icons.whitespace.to_string());

    let long = label(long).foreground(theme.colors.shortcut_long_fg);

    // TODO: Remove when size constraints are implemented

    let short_w = short.query(Attribute::Width).unwrap().unwrap_size();

    let divider_w = divider.query(Attribute::Width).unwrap().unwrap_size();

    let long_w = long.query(Attribute::Width).unwrap().unwrap_size();

    let width = short_w.saturating_add(divider_w).saturating_add(long_w);

    let shortcut = Shortcut::new(short, divider, long);

    Widget::new(shortcut).height(1).width(width)

}

pub fn shortcuts(theme: &Theme, shortcuts: Vec<Widget<Shortcut>>) -> Widget<Shortcuts> {

    let divider = label(&format!(" {} ", theme.icons.shortcutbar_divider))

        .foreground(theme.colors.shortcutbar_divider_fg);

    let shortcut_bar = Shortcuts::new(shortcuts, divider);

    Widget::new(shortcut_bar).height(1)

}

pub fn property(theme: &Theme, name: &str, value: &str) -> Widget<Property> {

    let name = label(name).foreground(theme.colors.property_name_fg);

    let divider = label(&format!(" {} ", theme.icons.property_divider));

    let value = label(value).foreground(theme.colors.default_fg);

    // TODO: Remove when size constraints are implemented

    let name_w = name.query(Attribute::Width).unwrap().unwrap_size();

    let divider_w = divider.query(Attribute::Width).unwrap().unwrap_size();

    let value_w = value.query(Attribute::Width).unwrap().unwrap_size();

    let width = name_w.saturating_add(divider_w).saturating_add(value_w);

    let property = Property::new(name, divider, value);

    Widget::new(property).height(1).width(width)

}

pub fn property_list(_theme: &Theme, properties: Vec<Widget<Property>>) -> Widget<PropertyList> {

    let property_list = PropertyList::new(properties);

    Widget::new(property_list)

}

pub fn tabs(theme: &Theme, tabs: Vec<Widget<Label>>) -> Widget<Tabs> {

    let divider = label(&theme.icons.tab_divider.to_string());

    let tabs = Tabs::new(tabs, divider);

    Widget::new(tabs)

        .height(1)

        .foreground(theme.colors.tabs_fg)

        .highlight(theme.colors.tabs_highlighted_fg)

}

pub fn table(theme: &Theme, items: &[impl List], profile: &Profile) -> Widget<Table> {

    let table = Table::default();

    let items = items.iter().map(|item| item.row(theme, profile)).collect();

    Widget::new(table)

        .content(AttrValue::Table(items))

        .background(theme.colors.labeled_container_bg)

        .highlight(theme.colors.item_list_highlighted_bg)

}

use radicle::cob::patch::{Patch, PatchId};

use radicle::identity::{Id, Project};

use radicle::Profile;

use tuirealm::props::{PropPayload, PropValue, TextSpan};

use tuirealm::AttrValue;

use crate::ui::components::container::Tabs;

use crate::ui::components::workspace::{Browser, Dashboard, IssueBrowser};

use crate::ui::theme::Theme;

use super::{common, Widget};

pub fn navigation(theme: &Theme) -> Widget<Tabs> {

    common::tabs(

        theme,

        vec![

            common::label("dashboard"),

            common::label("issues"),

            common::label("patches"),

        ],

    )

}

pub fn dashboard(theme: &Theme, id: &Id, project: &Project) -> Widget<Dashboard> {

    let about = common::labeled_container(

        theme,

        "about",

        common::property_list(

            theme,

            vec![

                common::property(theme, "id", &id.to_string()),

                common::property(theme, "name", project.name()),

                common::property(theme, "description", project.description()),

            ],

        )

        .to_boxed(),

    );

    let shortcuts = common::shortcuts(

        theme,

        vec![

            common::shortcut(theme, "tab", "section"),

            common::shortcut(theme, "q", "quit"),

        ],

    );

    let dashboard = Dashboard::new(about, shortcuts);

    Widget::new(dashboard)

}

pub fn patches(

    theme: &Theme,

    items: &[(PatchId, Patch)],

    profile: &Profile,

) -> Widget<Browser<(PatchId, Patch)>> {

    let shortcuts = common::shortcuts(

        theme,

        vec![

            common::shortcut(theme, "tab", "section"),

            common::shortcut(theme, "↑/↓", "navigate"),

            common::shortcut(theme, "enter", "show"),

            common::shortcut(theme, "q", "quit"),

        ],

    );

    let widths = AttrValue::Payload(PropPayload::Vec(vec![

        PropValue::U16(2),

        PropValue::U16(43),

        PropValue::U16(15),

        PropValue::U16(15),

        PropValue::U16(5),

        PropValue::U16(20),

    ]));

    let header = AttrValue::Payload(PropPayload::Vec(vec![

        PropValue::TextSpan(TextSpan::from("")),

        PropValue::TextSpan(TextSpan::from("title")),

        PropValue::TextSpan(TextSpan::from("author")),

        PropValue::TextSpan(TextSpan::from("tags")),

        PropValue::TextSpan(TextSpan::from("comments")),

        PropValue::TextSpan(TextSpan::from("date")),

    ]));

    let table = common::table(theme, items, profile)

        .custom("widths", widths)

        .custom("header", header);

    let browser: Browser<(PatchId, Patch)> = Browser::new(table, shortcuts);

    Widget::new(browser)

}

pub fn issues(theme: &Theme) -> Widget<IssueBrowser> {

    let shortcuts = common::shortcuts(

        theme,

        vec![

            common::shortcut(theme, "tab", "section"),

            common::shortcut(theme, "q", "quit"),

        ],

    );

    let not_implemented = common::label("not implemented").foreground(theme.colors.default_fg);

    let browser = IssueBrowser::new(not_implemented, shortcuts);

    Widget::new(browser)

}

use radicle::Profile;

use tuirealm::props::Color;

use radicle::cob::patch::{Patch, PatchId};

use super::common;

use super::Widget;

use crate::ui::cob::patch;

use crate::ui::components::container::Tabs;

use crate::ui::components::context::ContextBar;

use crate::ui::components::workspace::{PatchActivity, PatchFiles};

use crate::ui::theme::Theme;

pub fn navigation(theme: &Theme) -> Widget<Tabs> {

    common::tabs(

        theme,

        vec![common::label("activity"), common::label("files")],

    )

}

pub fn activity(

    theme: &Theme,

    patch: (PatchId, &Patch),

    profile: &Profile,

) -> Widget<PatchActivity> {

    let (id, patch) = patch;

    let shortcuts = common::shortcuts(

        theme,

        vec![

            common::shortcut(theme, "esc", "back"),

            common::shortcut(theme, "tab", "section"),

            common::shortcut(theme, "q", "quit"),

        ],

    );

    let context = context(theme, (id, patch), profile);

    let not_implemented = common::label("not implemented").foreground(theme.colors.default_fg);

    let activity = PatchActivity::new(not_implemented, context, shortcuts);

    Widget::new(activity)

}

pub fn files(theme: &Theme, patch: (PatchId, &Patch), profile: &Profile) -> Widget<PatchFiles> {

    let (id, patch) = patch;

    let shortcuts = common::shortcuts(

        theme,

        vec![

            common::shortcut(theme, "esc", "back"),

            common::shortcut(theme, "tab", "section"),

            common::shortcut(theme, "q", "quit"),

        ],

    );

    let context = context(theme, (id, patch), profile);

    let not_implemented = common::label("not implemented").foreground(theme.colors.default_fg);

    let files = PatchFiles::new(not_implemented, context, shortcuts);

    Widget::new(files)

}

pub fn context(_theme: &Theme, patch: (PatchId, &Patch), profile: &Profile) -> Widget<ContextBar> {

    let (id, patch) = patch;

    let id = patch::format_id(id);

    let title = patch.title();

    let author = patch::format_author(patch, profile);

    let comments = patch::format_comments(patch);

    let context = common::label(" patch ").background(Color::Rgb(238, 111, 248));

    let id = common::label(&format!(" {} ", id))

        .foreground(Color::Rgb(117, 113, 249))

        .background(Color::Rgb(40, 40, 40));

    let title = common::label(&format!(" {} ", title))

        .foreground(Color::Rgb(70, 70, 70))

        .background(Color::Rgb(40, 40, 40));

    let author = common::label(&format!(" {} ", author))

        .foreground(Color::Rgb(117, 113, 249))

        .background(Color::Rgb(40, 40, 40));

    let comments = common::label(&format!(" {} ", comments))

        .foreground(Color::Rgb(70, 70, 70))

        .background(Color::Rgb(50, 50, 50));

    let context_bar = ContextBar::new(context, id, author, title, comments);

    Widget::new(context_bar).height(1)

}