import json
import os
import sqlite3
from pathlib import Path

from app.config import APP_DATA_DIR


class SessionService:
    def __init__(self) -> None:
        self._db_path = Path(APP_DATA_DIR) / "session_state.sqlite3"
        self._db_path.parent.mkdir(parents=True, exist_ok=True)
        self._init_db()

    def _connect(self) -> sqlite3.Connection:
        conn = sqlite3.connect(self._db_path)
        conn.row_factory = sqlite3.Row
        return conn

    def _init_db(self) -> None:
        with self._connect() as conn:
            conn.execute(
                """
                CREATE TABLE IF NOT EXISTS selected_episodes (
                    selection_id INTEGER PRIMARY KEY AUTOINCREMENT,
                    session_id TEXT NOT NULL,
                    position INTEGER NOT NULL,
                    payload_json TEXT NOT NULL
                )
                """
            )
            conn.execute(
                """
                CREATE UNIQUE INDEX IF NOT EXISTS idx_selected_episodes_session_position
                ON selected_episodes(session_id, position)
                """
            )
            conn.execute(
                """
                CREATE INDEX IF NOT EXISTS idx_selected_episodes_session
                ON selected_episodes(session_id)
                """
            )
            conn.execute(
                """
                CREATE TABLE IF NOT EXISTS selected_files (
                    selection_id INTEGER PRIMARY KEY AUTOINCREMENT,
                    session_id TEXT NOT NULL,
                    position INTEGER NOT NULL,
                    payload_json TEXT NOT NULL
                )
                """
            )
            conn.execute(
                """
                CREATE UNIQUE INDEX IF NOT EXISTS idx_selected_files_session_position
                ON selected_files(session_id, position)
                """
            )
            conn.execute(
                """
                CREATE INDEX IF NOT EXISTS idx_selected_files_session
                ON selected_files(session_id)
                """
            )

    def list_selected_episodes(self, session_id: str) -> list[dict]:
        with self._connect() as conn:
            rows = conn.execute(
                """
                SELECT selection_id, position, payload_json
                FROM selected_episodes
                WHERE session_id = ?
                ORDER BY position ASC
                """,
                (session_id,),
            ).fetchall()

        items = []
        for row in rows:
            payload = json.loads(row["payload_json"])
            items.append(
                {
                    "selection_id": row["selection_id"],
                    "position": row["position"],
                    "episode": payload,
                }
            )
        return items

    def add_selected_episodes(self, session_id: str, items: list[dict]) -> list[dict]:
        if not items:
            return self.list_selected_episodes(session_id)

        with self._connect() as conn:
            current_max = conn.execute(
                """
                SELECT COALESCE(MAX(position), -1) AS max_position
                FROM selected_episodes
                WHERE session_id = ?
                """,
                (session_id,),
            ).fetchone()
            next_position = int(current_max["max_position"]) + 1

            for item in items:
                conn.execute(
                    """
                    INSERT INTO selected_episodes (session_id, position, payload_json)
                    VALUES (?, ?, ?)
                    """,
                    (session_id, next_position, json.dumps(item, ensure_ascii=True)),
                )
                next_position += 1

        return self.list_selected_episodes(session_id)

    def clear_selected_episodes(self, session_id: str) -> None:
        with self._connect() as conn:
            conn.execute(
                "DELETE FROM selected_episodes WHERE session_id = ?",
                (session_id,),
            )

    def remove_selected_episode(self, session_id: str, selection_id: int) -> list[dict]:
        with self._connect() as conn:
            conn.execute(
                """
                DELETE FROM selected_episodes
                WHERE session_id = ? AND selection_id = ?
                """,
                (session_id, selection_id),
            )
        return self._compact_positions(session_id)

    def reorder_selected_episodes(
        self,
        session_id: str,
        from_index: int,
        to_index: int,
    ) -> list[dict]:
        current_items = self.list_selected_episodes(session_id)

        if from_index < 0 or from_index >= len(current_items):
            raise ValueError("from_index out of range")
        if to_index < 0 or to_index >= len(current_items):
            raise ValueError("to_index out of range")
        if from_index == to_index:
            return current_items

        moved = current_items.pop(from_index)
        current_items.insert(to_index, moved)

        with self._connect() as conn:
            # Two-phase update avoids transient UNIQUE conflicts on (session_id, position).
            for position, item in enumerate(current_items):
                conn.execute(
                    """
                    UPDATE selected_episodes
                    SET position = ?
                    WHERE session_id = ? AND selection_id = ?
                    """,
                    (-(position + 1), session_id, item["selection_id"]),
                )

            for position, item in enumerate(current_items):
                conn.execute(
                    """
                    UPDATE selected_episodes
                    SET position = ?
                    WHERE session_id = ? AND selection_id = ?
                    """,
                    (position, session_id, item["selection_id"]),
                )

        return self.list_selected_episodes(session_id)

    def _compact_positions(self, session_id: str) -> list[dict]:
        items = self.list_selected_episodes(session_id)
        with self._connect() as conn:
            for position, item in enumerate(items):
                if item["position"] == position:
                    continue
                conn.execute(
                    """
                    UPDATE selected_episodes
                    SET position = ?
                    WHERE session_id = ? AND selection_id = ?
                    """,
                    (position, session_id, item["selection_id"]),
                )
        return self.list_selected_episodes(session_id)

    def list_selected_files(self, session_id: str) -> list[dict]:
        with self._connect() as conn:
            rows = conn.execute(
                """
                SELECT selection_id, position, payload_json
                FROM selected_files
                WHERE session_id = ?
                ORDER BY position ASC
                """,
                (session_id,),
            ).fetchall()

        items = []
        for row in rows:
            payload = json.loads(row["payload_json"])
            items.append(
                {
                    "selection_id": row["selection_id"],
                    "position": row["position"],
                    "file": payload,
                }
            )
        return items

    def add_selected_files(self, session_id: str, items: list[dict]) -> list[dict]:
        if not items:
            return self.list_selected_files(session_id)

        with self._connect() as conn:
            current_max = conn.execute(
                """
                SELECT COALESCE(MAX(position), -1) AS max_position
                FROM selected_files
                WHERE session_id = ?
                """,
                (session_id,),
            ).fetchone()
            next_position = int(current_max["max_position"]) + 1

            for item in items:
                conn.execute(
                    """
                    INSERT INTO selected_files (session_id, position, payload_json)
                    VALUES (?, ?, ?)
                    """,
                    (session_id, next_position, json.dumps(item, ensure_ascii=True)),
                )
                next_position += 1

        return self.list_selected_files(session_id)

    def clear_selected_files(self, session_id: str) -> None:
        with self._connect() as conn:
            conn.execute(
                "DELETE FROM selected_files WHERE session_id = ?",
                (session_id,),
            )

    def remove_selected_file(self, session_id: str, selection_id: int) -> list[dict]:
        with self._connect() as conn:
            conn.execute(
                """
                DELETE FROM selected_files
                WHERE session_id = ? AND selection_id = ?
                """,
                (session_id, selection_id),
            )
        return self._compact_file_positions(session_id)

    def reorder_selected_files(
        self,
        session_id: str,
        from_index: int,
        to_index: int,
    ) -> list[dict]:
        current_items = self.list_selected_files(session_id)

        if from_index < 0 or from_index >= len(current_items):
            raise ValueError("from_index out of range")
        if to_index < 0 or to_index >= len(current_items):
            raise ValueError("to_index out of range")
        if from_index == to_index:
            return current_items

        moved = current_items.pop(from_index)
        current_items.insert(to_index, moved)

        with self._connect() as conn:
            # Two-phase update avoids transient UNIQUE conflicts on (session_id, position).
            for position, item in enumerate(current_items):
                conn.execute(
                    """
                    UPDATE selected_files
                    SET position = ?
                    WHERE session_id = ? AND selection_id = ?
                    """,
                    (-(position + 1), session_id, item["selection_id"]),
                )

            for position, item in enumerate(current_items):
                conn.execute(
                    """
                    UPDATE selected_files
                    SET position = ?
                    WHERE session_id = ? AND selection_id = ?
                    """,
                    (position, session_id, item["selection_id"]),
                )

        return self.list_selected_files(session_id)

    def _compact_file_positions(self, session_id: str) -> list[dict]:
        items = self.list_selected_files(session_id)
        with self._connect() as conn:
            for position, item in enumerate(items):
                if item["position"] == position:
                    continue
                conn.execute(
                    """
                    UPDATE selected_files
                    SET position = ?
                    WHERE session_id = ? AND selection_id = ?
                    """,
                    (position, session_id, item["selection_id"]),
                )
        return self.list_selected_files(session_id)

    def build_mapping_preview(self, session_id: str) -> dict:
        episodes = self.list_selected_episodes(session_id)
        files = self.list_selected_files(session_id)

        if len(episodes) != len(files):
            raise ValueError(
                "Selected episodes and selected files count mismatch: "
                f"{len(episodes)} episodes vs {len(files)} files"
            )

        mappings = []
        for index, (episode_item, file_item) in enumerate(zip(episodes, files)):
            mappings.append(
                {
                    "index": index,
                    "episode_selection_id": episode_item["selection_id"],
                    "file_selection_id": file_item["selection_id"],
                    "episode": episode_item["episode"],
                    "file": file_item["file"],
                }
            )

        return {
            "session_id": session_id,
            "counts": {
                "episodes": len(episodes),
                "files": len(files),
            },
            "mappings": mappings,
        }

    def build_filename_preview(self, session_id: str) -> dict:
        mapping_preview = self.build_mapping_preview(session_id)
        previews = []

        for item in mapping_preview["mappings"]:
            episode = item["episode"]
            file_payload = item["file"]

            series = (
                episode.get("series")
                or episode.get("series_name")
                or episode.get("show")
                or "Unknown Series"
            )
            year = episode.get("year") or "0000"
            title = episode.get("title") or "Untitled"

            season_raw = episode.get("season_number") or episode.get("season") or 0
            episode_raw = episode.get("episode_number") or episode.get("number") or 0

            try:
                season_number = int(season_raw)
            except (TypeError, ValueError):
                season_number = 0
            try:
                episode_number = int(episode_raw)
            except (TypeError, ValueError):
                episode_number = 0

            source_name = file_payload.get("name") or file_payload.get("path") or ""
            ext = Path(source_name).suffix

            proposed_filename = (
                f"{series} ({year}) - S{season_number:02}E{episode_number:02} - {title}{ext}"
            )

            previews.append(
                {
                    "index": item["index"],
                    "episode_selection_id": item["episode_selection_id"],
                    "file_selection_id": item["file_selection_id"],
                    "episode": episode,
                    "file": file_payload,
                    "proposed_filename": proposed_filename,
                }
            )

        return {
            "session_id": mapping_preview["session_id"],
            "counts": mapping_preview["counts"],
            "template": "{series} ({year}) - S{season:02}E{episode:02} - {title}{ext}",
            "items": previews,
        }

    def execute_rename(self, session_id: str, confirm: bool) -> dict:
        if not confirm:
            raise ValueError("confirm=true is required to execute rename")

        preview = self.build_filename_preview(session_id)
        allowed_roots = self._allowed_media_roots()
        preflight_items = []
        preflight_errors = 0

        for item in preview["items"]:
            source_path_str = str(item["file"].get("path") or "").strip()
            proposed_filename = item["proposed_filename"]
            source_path = Path(source_path_str)

            destination_path = source_path.with_name(proposed_filename) if source_path_str else Path("")
            errors = self._preflight_errors(
                source_path=source_path,
                destination_path=destination_path,
                proposed_filename=proposed_filename,
                allowed_roots=allowed_roots,
            )

            status = "ready"
            if errors:
                status = "preflight_error"
                preflight_errors += 1

            preflight_items.append(
                {
                    "index": item["index"],
                    "episode_selection_id": item["episode_selection_id"],
                    "file_selection_id": item["file_selection_id"],
                    "source_path": source_path_str,
                    "destination_path": str(destination_path) if source_path_str else "",
                    "proposed_filename": proposed_filename,
                    "status": status,
                    "errors": errors,
                }
            )

        if preflight_errors > 0:
            return {
                "session_id": session_id,
                "confirm": confirm,
                "executed": False,
                "preflight_ok": False,
                "counts": preview["counts"],
                "items": preflight_items,
            }

        results = []
        for item in preflight_items:
            source_path = Path(item["source_path"])
            destination_path = Path(item["destination_path"])
            os.replace(str(source_path), str(destination_path))
            results.append(
                {
                    **item,
                    "status": "renamed",
                    "errors": [],
                }
            )

        return {
            "session_id": session_id,
            "confirm": confirm,
            "executed": True,
            "preflight_ok": True,
            "counts": preview["counts"],
            "items": results,
        }

    def _allowed_media_roots(self) -> list[Path]:
        raw = os.getenv("ALLOWED_MEDIA_ROOTS", "").strip()
        if raw:
            candidates = [p.strip() for p in raw.split(",") if p.strip()]
        else:
            media_root = os.getenv("MEDIA_ROOT", "").strip()
            if media_root:
                candidates = [media_root]
            else:
                candidates = [
                    "/Volumes/8TB/Shared_Folders/TV_Shows",
                    "/Volumes/8TB_RAID1/Shared_Folders/Library/TV_Shows",
                ]

        roots = []
        for candidate in candidates:
            try:
                roots.append(Path(candidate).resolve())
            except Exception:
                continue
        return roots

    def _is_within_allowed_roots(self, path: Path, allowed_roots: list[Path]) -> bool:
        try:
            resolved = path.resolve()
        except Exception:
            return False

        for root in allowed_roots:
            try:
                resolved.relative_to(root)
                return True
            except ValueError:
                continue
        return False

    def _preflight_errors(
        self,
        source_path: Path,
        destination_path: Path,
        proposed_filename: str,
        allowed_roots: list[Path],
    ) -> list[str]:
        errors = []

        if not str(source_path):
            errors.append("source path missing")
            return errors

        if ".." in source_path.parts:
            errors.append("source path traversal is not allowed")
        if ".." in Path(proposed_filename).parts:
            errors.append("destination filename traversal is not allowed")
        if Path(proposed_filename).name != proposed_filename:
            errors.append("destination filename must not contain path separators")

        if not self._is_within_allowed_roots(source_path, allowed_roots):
            errors.append("source path is outside allowed media roots")
        if not self._is_within_allowed_roots(destination_path, allowed_roots):
            errors.append("destination path is outside allowed media roots")

        if not source_path.exists():
            errors.append("source file does not exist")
        if source_path.exists() and not source_path.is_file():
            errors.append("source path is not a file")

        if source_path == destination_path:
            errors.append("source and destination paths are equal")

        if destination_path.exists():
            errors.append("destination file already exists")

        if not destination_path.parent.exists():
            errors.append("destination parent directory does not exist")

        return errors