use leptos::prelude::*;
use leptos_router::{components::A, nested_router::Outlet};

mod categories;
mod commands;
mod configs;
mod instances;
mod listeners;
mod templates;

#[allow(dead_code)]
pub use categories::CategoriesView;
#[allow(dead_code)]
pub use commands::CommandsView;
#[allow(dead_code)]
pub use configs::ConfigsView;
#[allow(dead_code)]
pub use instances::InstancesView;
#[allow(dead_code)]
pub use listeners::ListenersView;
#[allow(dead_code)]
pub use templates::TemplatesView;

#[derive(Clone)]
pub struct BeaconResources {
    add_listener: ServerAction<listeners::AddListener>,
    remove_listener: ServerAction<listeners::RemoveListener>,
    add_category: ServerAction<categories::AddCategory>,
    remove_category: ServerAction<categories::RemoveCategory>,
    rename_category: ServerAction<categories::RenameCategory>,
    add_beacon_config: ServerAction<configs::AddBeaconConfig>,
    remove_beacon_config: ServerAction<configs::RemoveBeaconConfig>,
    add_template: ServerAction<templates::AddTemplate>,
    remove_template: ServerAction<templates::RemoveTemplate>,

    listeners: Resource<Result<Vec<listeners::PubListener>, ServerFnError>>,
    categories: Resource<Result<Vec<categories::Category>, ServerFnError>>,
    configs: Resource<Result<Vec<configs::BeaconConfig>, ServerFnError>>,
    templates: Resource<Result<Vec<templates::BeaconTemplate>, ServerFnError>>
}

pub fn provide_beacon_resources() {
    let user = expect_context::<ReadSignal<Option<crate::users::User>>>();

    let add_listener = ServerAction::<listeners::AddListener>::new();
    let remove_listener = ServerAction::<listeners::RemoveListener>::new();

    let add_category = ServerAction::<categories::AddCategory>::new();
    let remove_category = ServerAction::<categories::RemoveCategory>::new();
    let rename_category = ServerAction::<categories::RenameCategory>::new();

    let add_beacon_config = ServerAction::<configs::AddBeaconConfig>::new();
    let remove_beacon_config = ServerAction::<configs::RemoveBeaconConfig>::new();

    let add_template = ServerAction::<templates::AddTemplate>::new();
    let remove_template = ServerAction::<templates::RemoveTemplate>::new();

    let listeners = Resource::new(
        move || (
            user.get(),
            add_listener.version().get(),
            remove_listener.version().get(),
        ),
        |_| async { listeners::get_listeners().await }
    );

    let categories = Resource::new(
        move || (
            user.get(),
            add_category.version().get(),
            remove_category.version().get(),
            rename_category.version().get(),
        ),
        |_| async { categories::get_categories().await }
    );

    let configs = Resource::new(
        move || (
            user.get(),
            add_beacon_config.version().get(),
            remove_beacon_config.version().get(),
        ),
        |_| async { configs::get_beacon_configs().await }
    );

    let templates = Resource::new(
        move || (
            user.get(),
            add_template.version().get(),
            remove_template.version().get()
        ),
        |_| async { templates::get_templates().await }
    );

    provide_context(BeaconResources {
        add_listener,
        remove_listener,
        add_category,
        remove_category,
        rename_category,
        add_beacon_config,
        remove_beacon_config,
        add_template,
        remove_template,

        listeners,
        categories,
        configs,
        templates
    });
}

#[component]
pub fn BeaconView() -> impl IntoView {
    #[cfg(feature = "hydrate")]
    Effect::new(move || {
        let user = expect_context::<ReadSignal<Option<crate::users::User>>>();
        if user.get().is_none() {
            let navigate = leptos_router::hooks::use_navigate();
            navigate("/login?next=beacons", Default::default());
        }
    });

    view! {
        <main class="beacons">
            <aside class="beacon-menu">
                <ul>
                    <li><A href="/beacons/listeners">"Listeners"</A></li>
                    <li><A href="/beacons/configs">"Configs"</A></li>
                    <li><A href="/beacons/categories">"Categories"</A></li>
                    <li><A href="/beacons/templates">"Templates"</A></li>
                    <li><A href="/beacons/commands">"Commands"</A></li>
                </ul>
            </aside>

            <Outlet />
        </main>
    }
}

enum SortMethod {
    Listener,
    Config,
    Category,
    Template
}

impl std::str::FromStr for SortMethod {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "Listener" => Ok(Self::Listener),
            "Config" => Ok(Self::Config),
            "Category" => Ok(Self::Category),
            "Template" => Ok(Self::Template),
            &_ => Err(())
        }
    }
}

impl std::string::ToString for SortMethod {
    fn to_string(&self) -> String {
        use SortMethod as SM;
        match self {
            SM::Listener => "Listener",
            SM::Config => "Config",
            SM::Category => "Category",
            SM::Template => "Template",
        }.to_string()
    }
}

#[component]
pub fn BeaconSidebar() -> impl IntoView {
    let (sort_method, set_sort_method) = signal(SortMethod::Category);
    let search_input = RwSignal::new("".to_string());

    view! {
        <aside class="beacons">
            <div class="sort-method">

            </div>
            <div class="search">

            </div>
        </aside>
    }
}