//! Share creation dialog and the "Your shares" management panel (milestone 6).

use leptos::prelude::*;
use wasm_bindgen::JsCast;
use wasm_bindgen_futures::spawn_local;

use crate::api::{self, ShareInfo};
use crate::components::toast::{show, ToastMsg};
use crate::router::share_url;
use crate::util::format_date;

// ---------------------------------------------------------------------------
// Expiry helpers (compute the RFC 3339 expiry client-side)
// ---------------------------------------------------------------------------

/// Format a millisecond timestamp as an RFC 3339 UTC string.
fn ms_to_rfc3339(ms: f64) -> Option<String> {
    if ms.is_nan() {
        return None;
    }
    let secs = (ms / 1000.0) as i64;
    chrono::DateTime::from_timestamp(secs, 0)
        .map(|dt| dt.to_rfc3339_opts(chrono::SecondsFormat::Secs, true))
}

/// Convert the user's expiry choice into an RFC 3339 timestamp, or `None` for
/// "never". Presets are computed from "now"; "custom" parses the
/// datetime-local value as the browser's local time.
fn expiry_to_rfc3339(choice: &str, custom: &str) -> Option<String> {
    let now = js_sys::Date::now();
    let h = 60.0 * 60.0 * 1000.0;
    let target_ms: Option<f64> = match choice {
        "never" => return None,
        "1h" => Some(now + h),
        "1d" => Some(now + 24.0 * h),
        "1w" => Some(now + 7.0 * 24.0 * h),
        "1mo" => Some(now + 30.0 * 24.0 * h),
        "custom" => {
            if custom.is_empty() {
                None
            } else {
                // `Date.parse` treats a bare datetime as local time, so the
                // result is already the correct UTC instant.
                Some(js_sys::Date::parse(custom))
            }
        }
        _ => return None,
    };
    target_ms.and_then(ms_to_rfc3339)
}

fn copy_to_clipboard(text: &str, toast: ToastMsg) {
    let Some(win) = web_sys::window() else {
        show(toast, "Copy the link manually".to_string());
        return;
    };
    let cb = win.navigator().clipboard();
    let t = text.to_string();
    spawn_local(async move {
        let _ = wasm_bindgen_futures::JsFuture::from(cb.write_text(&t)).await;
        show(toast, "Link copied to clipboard".to_string());
    });
}

fn select_value(ev: &web_sys::Event) -> Option<String> {
    ev.target()
        .and_then(|t| t.dyn_into::<web_sys::HtmlSelectElement>().ok())
        .map(|s| s.value())
}

// ---------------------------------------------------------------------------
// Share creation dialog (two-phase: form -> link)
// ---------------------------------------------------------------------------

#[component]
pub fn ShareDialog(
    name: String,
    root_id: i64,
    path: String,
    allow_writable: bool,
    close: Callback<()>,
) -> impl IntoView {
    let toast = use_context::<ToastMsg>().expect("toast context");
    let (writable, set_writable) = signal(false);
    let (choice, set_choice) = signal("never".to_string());
    let (custom, set_custom) = signal(String::new());
    let (created, set_created) = signal(Option::<ShareInfo>::None);
    let (busy, set_busy) = signal(false);

    let do_create = move |_| {
        if busy.get() {
            return;
        }
        set_busy.set(true);
        let exp = expiry_to_rfc3339(&choice.get(), &custom.get());
        let wr = writable.get();
        let rid = root_id;
        let p = path.clone();
        spawn_local(async move {
            match api::create_share(rid, &p, wr, exp.as_deref()).await {
                Ok(info) => set_created.set(Some(info)),
                Err(e) => {
                    show(toast, format!("Could not create share: {e}"));
                    set_busy.set(false);
                }
            }
        });
    };

    view! {
        <div class="modal-overlay" on:click=move |_| close.run(())>
            <div
                class="modal share-modal"
                on:click=move |ev: web_sys::MouseEvent| ev.stop_propagation()
            >
                {move || match created.get() {
                    Some(ref info) => {
                        let link = share_url(&info.token);
                        view! {
                            <h2 class="modal-title">"Share link"</h2>
                            <p class="modal-message">
                                "Anyone with this link can "
                                {if writable.get() { "read and write " } else { "read " }}
                                {format!("“{name}”.")}
                            </p>
                            <div class="share-link-row">
                                <input
                                    class="share-link-input"
                                    readonly=true
                                    value=link.clone()
                                    on:click=move |ev: web_sys::MouseEvent| {
                                        if let Some(i) = ev
                                            .target()
                                            .and_then(|t| t.dyn_into::<web_sys::HtmlInputElement>().ok())
                                        {
                                            i.select();
                                        }
                                    }
                                />
                                <button class="btn" on:click=move |_| copy_to_clipboard(&link, toast)>"Copy"</button>
                            </div>
                            <p class="muted share-expiry-note">
                                {match info.expires_at {
                                    Some(ref e) => format!("Expires {0}", format_date(e)),
                                    None => "Never expires".to_string(),
                                }}
                            </p>
                            <div class="modal-actions">
                                <button class="btn btn-primary" on:click=move |_| close.run(())>"Done"</button>
                            </div>
                        }
                        .into_view()
                        .into_any()
                    }
                    None => view! {
                        <h2 class="modal-title">{format!("Share {name}")}</h2>
                        <p class="modal-message">"Create a link for this item. Writable links let viewers upload and edit."</p>
                        {move || if allow_writable {
                            view! {
                                <label class="share-check">
                                    <input
                                        type="checkbox"
                                        checked=move || writable.get()
                                        on:change=move |ev: web_sys::Event| {
                                            if let Some(t) = ev
                                                .target()
                                                .and_then(|t| t.dyn_into::<web_sys::HtmlInputElement>().ok())
                                            {
                                                set_writable.set(t.checked());
                                            }
                                        }
                                    />
                                    "Allow editing (read-write)"
                                </label>
                            }
                            .into_view()
                            .into_any()
                        } else {
                            view! {
                                <p class="muted">"Writable shares are disabled by the server."</p>
                            }
                            .into_view()
                            .into_any()
                        }}
                        <div class="share-expiry-row">
                            <label for="share-expiry">"Expires"</label>
                            <select
                                id="share-expiry"
                                on:change=move |ev: web_sys::Event| {
                                    if let Some(v) = select_value(&ev) {
                                        set_choice.set(v);
                                    }
                                }
                            >
                                <option value="never">"Never"</option>
                                <option value="1h">"1 hour"</option>
                                <option value="1d">"1 day"</option>
                                <option value="1w">"1 week"</option>
                                <option value="1mo">"1 month"</option>
                                <option value="custom">"Custom…"</option>
                            </select>
                        </div>
                        {move || if choice.get() == "custom" {
                            view! {
                                <div class="share-expiry-row">
                                    <label for="share-custom-dt">"Until"</label>
                                    <input
                                        type="datetime-local"
                                        id="share-custom-dt"
                                        value=move || custom.get()
                                        on:change=move |ev: web_sys::Event| {
                                            if let Some(t) = ev
                                                .target()
                                                .and_then(|t| t.dyn_into::<web_sys::HtmlInputElement>().ok())
                                            {
                                                set_custom.set(t.value());
                                            }
                                        }
                                    />
                                </div>
                            }
                            .into_view()
                            .into_any()
                        } else {
                            view! {}.into_any()
                        }}
                        <div class="modal-actions">
                            <button class="btn" on:click=move |_| close.run(())>"Cancel"</button>
                            <button
                                class="btn btn-primary"
                                disabled=move || busy.get()
                                on:click=do_create.clone()
                            >
                                {move || if busy.get() { "Creating…" } else { "Create link" }}
                            </button>
                        </div>
                    }
                    .into_view()
                    .into_any(),
                }}
            </div>
        </div>
    }
}

// ---------------------------------------------------------------------------
// "Your shares" management panel
// ---------------------------------------------------------------------------

#[component]
pub fn SharesPanel(close: Callback<()>) -> impl IntoView {
    let toast = use_context::<ToastMsg>().expect("toast context");
    let (shares, set_shares) = signal(Option::<Vec<ShareInfo>>::None);
    {
        let set = set_shares;
        let toast2 = toast;
        spawn_local(async move {
            match api::list_shares().await {
                Ok(s) => set.set(Some(s)),
                Err(e) => show(toast2, e.to_string()),
            }
        });
    }

    view! {
        <div class="modal-overlay" on:click=move |_| close.run(())>
            <div
                class="modal shares-panel"
                on:click=move |ev: web_sys::MouseEvent| ev.stop_propagation()
            >
                <h2 class="modal-title">"Your shares"</h2>
                {move || match shares.get() {
                    None => view! {
                        <p class="muted">"Loading…"</p>
                    }
                    .into_view()
                    .into_any(),
                    Some(ref list) if list.is_empty() => view! {
                        <p class="muted">"No shares yet. Right-click a file or folder and choose “Share”."</p>
                    }
                    .into_view()
                    .into_any(),
                    Some(ref list) => {
                        let items = list
                            .iter()
                            .map(|s| {
                                let s2 = s.clone();
                                let link = share_url(&s.token);
                                let mut meta = format!(
                                    "{} · {}",
                                    s.target,
                                    if s.writable { "read-write" } else { "read-only" }
                                );
                                if let Some(e) = &s.expires_at {
                                    meta.push_str(&format!(" · expires {}", format_date(e)));
                                }
                                meta.push_str(&format!(" · created {}", format_date(&s.created_at)));
                                view! {
                                    <div class="share-item">
                                        <div class="share-item-main">
                                            <div class="share-item-name">
                                                {if s.is_file { "📄" } else { "📁" }}
                                                {" "}{s.name.clone()}
                                            </div>
                                            <div class="share-item-meta muted">{meta}</div>
                                        </div>
                                        <div class="share-item-actions">
                                            <button
                                                class="btn btn-sm"
                                                title="Copy link"
                                                on:click=move |_| copy_to_clipboard(&link, toast)
                                            >"Copy"</button>
                                            <button
                                                class="btn btn-sm btn-danger"
                                                title="Delete share"
                                                on:click=move |_| {
                                                    let id = s2.id;
                                                    let read = shares;
                                                    let write = set_shares;
                                                    let toast2 = toast;
                                                    spawn_local(async move {
                                                        if api::delete_share(id).await.is_ok() {
                                                            if let Some(mut cur) = read.get() {
                                                                cur.retain(|x| x.id != id);
                                                                write.set(Some(cur));
                                                            }
                                                        } else {
                                                            show(toast2, "Could not delete share".to_string());
                                                        }
                                                    });
                                                }
                                            >"Delete"</button>
                                        </div>
                                    </div>
                                }
                            })
                            .collect::<Vec<_>>();
                        view! {
                            <div class="share-list">{items}</div>
                        }
                    }
                    .into_view()
                    .into_any(),
                }}
                <div class="modal-actions">
                    <button class="btn" on:click=move |_| close.run(())>"Close"</button>
                </div>
            </div>
        </div>
    }
}