"""Workspaces : composition de l'espace de travail (onglets, splits, tailles),
enregistrable et restaurable.

Un workspace ne reference les sessions SSH que par id : jamais de mot de passe
ni de secret stocke ici (la connexion, une fois restauree, redemande un
mot de passe/passphrase exactement comme une ouverture normale)."""
from __future__ import annotations

import uuid
from dataclasses import asdict, dataclass, field
from pathlib import Path

from app.paths import DATA_DIR
from app.storage.json_store import load_json_document, save_json_document

WORKSPACES_FILE = DATA_DIR / "workspaces.json"
SCHEMA_VERSION = 1

ITEM_SESSION_SSH = "session_ssh"    # onglet terminal pour une session enregistree
ITEM_SESSION_SFTP = "session_sftp"  # onglet SFTP pour une session enregistree
ITEM_LOCAL_SHELL = "local_shell"    # terminal local


@dataclass
class WorkspaceItem:
    """Contenu d'un onglet ou d'un panneau."""
    kind: str = ITEM_LOCAL_SHELL
    session_id: str = ""  # kind in (session_ssh, session_sftp)
    shell: str = ""       # kind == local_shell

    def to_dict(self) -> dict:
        return asdict(self)

    @staticmethod
    def from_dict(data: dict) -> WorkspaceItem:
        item = WorkspaceItem()
        for k in WorkspaceItem.__dataclass_fields__:
            if k in data:
                setattr(item, k, data[k])
        return item


@dataclass
class WorkspaceTab:
    title: str = ""
    layout: str = "1"  # cf. app.ui.split_pane : "1" | "2v" | "2h" | "4"
    items: list[WorkspaceItem] = field(default_factory=list)
    splitter_sizes: list[list[int]] = field(default_factory=list)

    def to_dict(self) -> dict:
        return {
            "title": self.title,
            "layout": self.layout,
            "items": [i.to_dict() for i in self.items],
            "splitter_sizes": [list(s) for s in self.splitter_sizes],
        }

    @staticmethod
    def from_dict(data: dict) -> WorkspaceTab:
        tab = WorkspaceTab(title=data.get("title", ""), layout=data.get("layout", "1"))
        tab.items = [WorkspaceItem.from_dict(i) for i in data.get("items", [])]
        tab.splitter_sizes = [list(s) for s in data.get("splitter_sizes", [])]
        return tab


@dataclass
class Workspace:
    id: str = field(default_factory=lambda: str(uuid.uuid4()))
    name: str = ""
    tabs: list[WorkspaceTab] = field(default_factory=list)

    def to_dict(self) -> dict:
        return {"id": self.id, "name": self.name, "tabs": [t.to_dict() for t in self.tabs]}

    @staticmethod
    def from_dict(data: dict) -> Workspace:
        ws = Workspace(id=data.get("id") or str(uuid.uuid4()), name=data.get("name", ""))
        ws.tabs = [WorkspaceTab.from_dict(t) for t in data.get("tabs", [])]
        return ws


class WorkspaceStore:
    """Charge/sauvegarde la liste des workspaces depuis data/workspaces.json."""

    def __init__(self, path: Path = WORKSPACES_FILE):
        self.path = path
        self.workspaces: list[Workspace] = []
        self.load_warning: str | None = None
        self.load()

    def load(self) -> None:
        was_missing = not self.path.exists()
        document, warning = load_json_document(
            self.path,
            default={"schema_version": SCHEMA_VERSION, "workspaces": []},
            current_version=SCHEMA_VERSION,
        )
        self.load_warning = warning
        self.workspaces = [Workspace.from_dict(w) for w in document.get("workspaces", [])]
        if was_missing:
            self.save()

    def save(self) -> None:
        payload = {"schema_version": SCHEMA_VERSION, "workspaces": [w.to_dict() for w in self.workspaces]}
        save_json_document(self.path, payload)

    def get(self, workspace_id: str) -> Workspace | None:
        return next((w for w in self.workspaces if w.id == workspace_id), None)

    def add(self, workspace: Workspace) -> None:
        self.workspaces.append(workspace)
        self.save()

    def update(self, workspace: Workspace) -> None:
        for i, w in enumerate(self.workspaces):
            if w.id == workspace.id:
                self.workspaces[i] = workspace
                break
        self.save()

    def delete(self, workspace_id: str) -> None:
        self.workspaces = [w for w in self.workspaces if w.id != workspace_id]
        self.save()