//! Optional hosted transport state. The Document remains the local editing history.
pub mod client;
pub mod view;

use client::{Catalog, Connection, Failure, Remote, Secret, Summary};
use oa_core::{Id, source_project::CompiledSourceProject};
use std::sync::Arc;

#[derive(Debug, Clone)]
pub enum Event {
    Show,
    Close,
    Base(String),
    Token(Secret),
    Query(String),
    Connect,
    More,
    Select(Id),
    OpenSelected,
    Publish,
    Save,
    Check,
    Reload,
    ReviewFile(String),
    ReviewAction(iced::widget::text_editor::Action),
    ReviewBack,
    Local,
    Forget,
    Completed(Id, Id, Result<Outcome, Failure>),
}

#[derive(Debug, Clone)]
pub enum Outcome {
    Catalog(Catalog),
    Remote(Remote),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Operation {
    Catalog(bool),
    Open(Id),
    Publish,
    Save,
    Check,
}

#[derive(Debug, Clone)]
pub struct Session {
    pub connection: Connection,
    pub resource_id: Id,
    pub revision: u64,
    pub etag: String,
}

#[derive(Debug, Clone)]
pub struct Request {
    pub id: Id,
    pub document: Id,
    pub revision: u64,
    pub operation: Operation,
    pub connection: Connection,
    pub resource_id: Option<Id>,
    pub etag: Option<String>,
    pub snapshot: Arc<CompiledSourceProject>,
}

#[derive(Debug, Clone)]
pub struct Review {
    pub connection: Connection,
    pub remote: Remote,
}

pub struct State {
    pub visible: bool,
    pub base: String,
    pub token: Secret,
    pub query: String,
    pub catalog: Vec<Summary>,
    pub catalog_stale: bool,
    pub next: Option<Id>,
    pub selected: Option<Id>,
    pub connection: Option<Connection>,
    pub session: Option<Session>,
    pub request: Option<Request>,
    pub uncertain: Option<Request>,
    pub review: Option<Review>,
    pub review_path: Option<String>,
    pub review_editor: iced::widget::text_editor::Content,
    pub error: Option<Failure>,
    pub open_target: Option<(Connection, Id)>,
}

impl Default for State {
    fn default() -> Self {
        Self {
            visible: false,
            base: "http://127.0.0.1:8787".into(),
            token: Secret::default(),
            query: String::new(),
            catalog: vec![],
            catalog_stale: true,
            next: None,
            selected: None,
            connection: None,
            session: None,
            request: None,
            uncertain: None,
            review: None,
            review_path: None,
            review_editor: iced::widget::text_editor::Content::new(),
            error: None,
            open_target: None,
        }
    }
}

impl State {
    pub fn invalidate_catalog(&mut self) {
        self.catalog_stale = true;
        self.next = None;
    }

    pub fn catalog_message(&self) -> Option<&'static str> {
        if self.connection.is_none() {
            Some("Connect / refresh to load models for this service.")
        } else if self.catalog_stale {
            Some("Catalog may be out of date. Connect / refresh to update these results.")
        } else if self.catalog.is_empty() {
            Some("No models found. Publish the current model or change the search.")
        } else {
            None
        }
    }

    /// Keep explicit connection settings in memory, but never carry a resource
    /// binding or in-flight result into another local document.
    pub fn leave_document(&mut self) {
        self.visible = false;
        self.session = None;
        self.request = None;
        self.uncertain = None;
        self.review = None;
        self.review_path = None;
        self.review_editor = iced::widget::text_editor::Content::new();
        self.error = None;
        self.open_target = None;
    }
}