//! Full-page file view (opened files take over the whole content area).
//!
//! The top bar doubles as the file's header: the file name where the brand
//! was, with save/close on the right. Used by both the signed-in shell and
//! the public share page.

use crate::i18n;
use api_types::FileKind;
use leptos::prelude::*;

use crate::api;
use crate::components::icon::Icon;
use crate::components::toast::{ToastMsg, show};
use crate::editor::{EditTarget, Editor};
use crate::icons::{IconName, icon_for};
use crate::preview::{Preview, PreviewKind, PreviewTarget};

/// A file that is open in the full-page view.
#[derive(Clone)]
pub enum FileView {
    /// Image / PDF / video / audio.
    Preview(PreviewTarget, PreviewKind),
    /// Text file; `EditTarget.readonly` decides whether it is editable.
    Editor(EditTarget),
    /// No built-in viewer for this kind: show a message + download button.
    Unsupported(UnsupportedTarget),
}

/// A file the app cannot preview (binary, archive, ...).
#[derive(Clone)]
pub struct UnsupportedTarget {
    pub root_id: i64,
    /// Path relative to the root.
    pub path: String,
    /// Display name.
    pub name: String,
    /// Sniffed kind, for the icon.
    pub kind: FileKind,
}

impl FileView {
    pub fn name(&self) -> &str {
        match self {
            FileView::Preview(t, _) => &t.name,
            FileView::Editor(t) => &t.name,
            FileView::Unsupported(t) => &t.name,
        }
    }

    /// The glyph shown next to the name in the top bar.
    pub fn icon(&self) -> IconName {
        match self {
            FileView::Preview(_t, kind) => match kind {
                PreviewKind::Image => IconName::Image,
                PreviewKind::Pdf => IconName::Pdf,
                PreviewKind::Video => IconName::Video,
                PreviewKind::Audio => IconName::Audio,
            },
            FileView::Editor(t) => icon_for(FileKind::Text, &t.name),
            FileView::Unsupported(t) => icon_for(t.kind, &t.name),
        }
    }

    /// Root the file lives in (for the download link).
    pub fn root_id(&self) -> i64 {
        match self {
            FileView::Preview(t, _) => t.root_id,
            FileView::Editor(t) => t.root_id,
            FileView::Unsupported(t) => t.root_id,
        }
    }

    /// Path relative to the root (for the download link).
    pub fn path(&self) -> &str {
        match self {
            FileView::Preview(t, _) => &t.path,
            FileView::Editor(t) => &t.path,
            FileView::Unsupported(t) => &t.path,
        }
    }

    /// True when the file is shown read-only (a text file in a read-only
    /// root). Media is always "read-only" in the sense that there is no
    /// save action; only the editor exposes the badge.
    pub fn readonly(&self) -> bool {
        matches!(self, FileView::Editor(t) if t.readonly)
    }
}

/// Top-bar replacement for the brand: file icon + name (with a dirty dot)
/// and, for read-only text files, a badge.
#[component]
pub fn FileViewTitle(view: FileView, dirty: ReadSignal<bool>) -> impl IntoView {
    let name = view.name().to_string();
    let icon = view.icon();
    let readonly = view.readonly();
    view! {
        <div class="file-title">
            <Icon name=icon class="file-title-icon".to_string()/>
            <span class="file-title-name">
                {move || {
                    let dot = if dirty.get() { " •" } else { "" };
                    format!("{name}{dot}")
                }}
            </span>
            {move || {
                if readonly {
                    view! { <span class="badge">{i18n::t(i18n::k::READ_ONLY_BADGE)}</span> }.into_view().into_any()
                } else {
                    view! {}.into_any()
                }
            }}
        </div>
    }
}

/// Top-bar actions: Save (only present while an editable file has
/// registered its save callback), Download and close.
#[component]
pub fn FileViewActions(
    /// The open file — the download button targets it.
    view: FileView,
    saving: ReadSignal<bool>,
    dirty: ReadSignal<bool>,
    save_cb: ReadSignal<Option<Callback<()>>>,
    /// The editor registers its close request here (it asks about unsaved
    /// changes first); other views close directly.
    close_cb: ReadSignal<Option<Callback<()>>>,
    /// Whether the close button is shown at all: closing means "back to
    /// the listing", so it is hidden when there is nothing to go back to
    /// (file shares).
    show_close: bool,
    on_close: Callback<()>,
    toast: ToastMsg,
) -> impl IntoView {
    // Serves the file from disk (for an open editor: the saved version,
    // not the working copy). Built once per open file — nothing about it
    // is reactive.
    let download_btn = {
        let dl = view;
        view! {
            <button
                class="icon-btn file-download"
                title={i18n::tr(i18n::k::DOWNLOAD)}
                aria-label={i18n::tr(i18n::k::DOWNLOAD)}
                on:click=move |_| {
                    let url = api::download_url(dl.root_id(), dl.path(), None);
                    api::trigger_download(&url, dl.name());
                    show(toast, i18n::t(i18n::k::DOWNLOAD_STARTED));
                }
            >
                <Icon name=IconName::Download class="ic-btn".to_string()/>
            </button>
        }
    };
    view! {
        <div class="file-actions">
            {move || match save_cb.get() {
                Some(cb) => view! {
                    <button
                        class="btn btn-sm btn-primary"
                        disabled=move || !dirty.get() || saving.get()
                        on:click=move |_| cb.run(())
                    >
                        {move || {
                            if saving.get() {
                                i18n::t(i18n::k::SAVING).to_string()
                            } else {
                                i18n::t(i18n::k::SAVE).to_string()
                            }
                        }}
                    </button>
                }
                .into_view()
                .into_any(),
                None => view! {}.into_any(),
            }}
            {download_btn}
            <Show when=move || show_close>
                <button
                    class="icon-btn file-close"
                    title={i18n::tr(i18n::k::CLOSE_ESC)}
                    aria-label={i18n::tr(i18n::k::CLOSE)}
                    on:click=move |_| {
                        if let Some(cb) = close_cb.get() {
                            cb.run(());
                        } else {
                            on_close.run(());
                        }
                    }
                >
                    <Icon name=IconName::Close class="ic-btn".to_string()/>
                </button>
            </Show>
        </div>
    }
}

/// The full-page content: preview, editor, or the "no preview" fallback.
#[component]
pub fn FileViewContent(
    view: FileView,
    register_save: WriteSignal<Option<Callback<()>>>,
    register_close: WriteSignal<Option<Callback<()>>>,
    dirty: ReadSignal<bool>,
    set_dirty: WriteSignal<bool>,
    set_saving: WriteSignal<bool>,
    close: Callback<()>,
    toast: ToastMsg,
    /// Re-fetch the (hidden, still mounted) browser after a save.
    refresh: Callback<()>,
) -> impl IntoView {
    match view {
        FileView::Preview(target, kind) => view! {
            <div class="file-view">
                <Preview target=target kind=kind/>
            </div>
        }
        .into_view()
        .into_any(),
        FileView::Editor(target) => view! {
            <div class="file-view">
                <Editor
                    target=target
                    register_save=register_save
                    register_close=register_close
                    dirty=dirty
                    set_dirty=set_dirty
                    set_saving=set_saving
                    close=close
                    toast=toast
                    refresh=refresh
                />
            </div>
        }
        .into_view()
        .into_any(),
        FileView::Unsupported(target) => view! {
            <div class="file-view">
                <NoPreview target=target/>
            </div>
        }
        .into_view()
        .into_any(),
    }
}

/// Shown for files with no built-in viewer: a message and a download button.
#[component]
fn NoPreview(target: UnsupportedTarget) -> impl IntoView {
    let icon = icon_for(target.kind, &target.name);
    let name = target.name.clone();
    let t = target;
    view! {
        <div class="file-nopreview">
            <div class="empty-state">
                <Icon name=icon class="empty-glyph".to_string()/>
                <h3>{i18n::tr(i18n::k::NO_PREVIEW)}</h3>
                <p class="muted">{i18n::t_fmt(i18n::k::NO_PREVIEW_MSG, &name)}</p>
                <button
                    class="btn btn-primary"
                    on:click=move |_| {
                        let url = api::download_url(t.root_id, &t.path, None);
                        api::trigger_download(&url, &name);
                    }
                >
                    <Icon name=IconName::Download class="ic-btn".to_string()/>
                    {i18n::tr(i18n::k::DOWNLOAD)}
                </button>
            </div>
        </div>
    }
}