"""Retrieve existing Salesforce metadata (repo or org) before the developer edits it."""

from __future__ import annotations

import asyncio
import json
import tempfile
from pathlib import Path
from typing import Dict, List, Optional, Protocol

import httpx
import structlog
from pydantic import BaseModel, Field

from packages.config import Settings, get_settings
from packages.integrations.github_repo import GitHubRepoReader, repo_reader_available

logger = structlog.get_logger(__name__)

_SOURCE_ROOT = "force-app/main/default/"


class MetadataRequest(BaseModel):
    metadata_type: str
    member: str
    paths: List[str] = Field(default_factory=list)


class RetrievedMetadata(BaseModel):
    source: str
    files: Dict[str, str] = Field(default_factory=dict)
    missing: List[str] = Field(default_factory=list)
    message: str = ""

    def has_any(self, paths: List[str]) -> bool:
        return any(p in self.files for p in paths)


class MetadataRetriever(Protocol):
    async def retrieve(self, requests: List[MetadataRequest]) -> RetrievedMetadata: ...


class MockMetadataRetriever:
    """Returns only files seeded via `existing` (empty by default)."""

    def __init__(self) -> None:
        self.existing: Dict[str, str] = {}
        self.calls: List[List[str]] = []

    async def retrieve(self, requests: List[MetadataRequest]) -> RetrievedMetadata:
        self.calls.append([f"{r.metadata_type}:{r.member}" for r in requests])
        result = RetrievedMetadata(source="mock")
        for req in requests:
            for path in req.paths:
                if path in self.existing:
                    result.files[path] = self.existing[path]
                else:
                    result.missing.append(path)
        result.message = f"Mock retrieve: {len(result.files)} existing file(s)"
        return result


class GitHubMetadataRetriever:
    """Read current versions of planned files from the default branch."""

    def __init__(self, settings: Optional[Settings] = None, reader: Optional[GitHubRepoReader] = None) -> None:
        self.settings = settings or get_settings()
        self.reader = reader or GitHubRepoReader(self.settings)

    async def retrieve(self, requests: List[MetadataRequest]) -> RetrievedMetadata:
        result = RetrievedMetadata(source=f"repo:{self.reader.owner}/{self.reader.repo}@{self.reader.branch}")
        try:
            known = set(await self.reader.list_paths())
        except httpx.HTTPError as exc:
            result.message = f"Repo listing failed: {exc}"
            result.missing = [p for r in requests for p in r.paths]
            return result
        for req in requests:
            for path in req.paths:
                if path not in known:
                    result.missing.append(path)
                    continue
                try:
                    content = await self.reader.read_file(path)
                except httpx.HTTPError as exc:
                    logger.warning("metadata_retrieve_read_failed", path=path, error=str(exc))
                    content = None
                if content is None:
                    result.missing.append(path)
                else:
                    result.files[path] = content
        result.message = f"Retrieved {len(result.files)} existing file(s) from repo"
        return result


class CliMetadataRetriever:
    """`sf project retrieve start --metadata` from the lower-org alias into a temp dir."""

    def __init__(self, settings: Optional[Settings] = None) -> None:
        self.settings = settings or get_settings()

    async def retrieve(self, requests: List[MetadataRequest]) -> RetrievedMetadata:
        from packages.integrations.salesforce import _looks_like_production

        alias = (self.settings.salesforce_org_alias or "").strip()
        if not alias:
            raise ValueError("SALESFORCE_ORG_ALIAS is required for the cli metadata retriever")
        if _looks_like_production(alias):
            raise ValueError(f"Refusing metadata retrieve from production-like alias '{alias}'")

        result = RetrievedMetadata(source=f"org:{alias}")
        if not requests:
            return result

        with tempfile.TemporaryDirectory(prefix="agent-nova-retrieve-") as tmp:
            cmd = ["sf", "project", "retrieve", "start", "--target-org", alias, "--output-dir", tmp, "--json"]
            for req in requests:
                cmd.extend(["--metadata", f"{req.metadata_type}:{req.member}"])
            proc = await asyncio.create_subprocess_exec(
                *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
            )
            stdout_b, stderr_b = await proc.communicate()
            try:
                payload = json.loads((stdout_b or b"").decode("utf-8", errors="replace") or "{}")
            except json.JSONDecodeError:
                payload = {}

            retrieved = {
                str(p.relative_to(tmp)).replace("\\", "/"): p
                for p in Path(tmp).rglob("*")
                if p.is_file()
            }
            for req in requests:
                for path in req.paths:
                    tail = path[len(_SOURCE_ROOT):] if path.startswith(_SOURCE_ROOT) else path
                    match = next((f for rel, f in retrieved.items() if rel.endswith(tail)), None)
                    if match is None:
                        result.missing.append(path)
                    else:
                        result.files[path] = match.read_text(encoding="utf-8", errors="replace")

        stderr = (stderr_b or b"").decode("utf-8", errors="replace").strip()
        result.message = (
            f"Retrieved {len(result.files)} existing file(s) from {alias}"
            if proc.returncode == 0
            else f"sf retrieve exited {proc.returncode}: {payload.get('message') or stderr[:300]}"
        )
        return result


def metadata_member(metadata_type: str, api_name: str, obj: Optional[str], paths: List[str]) -> str:
    if metadata_type in ("CustomField", "ValidationRule"):
        return f"{obj or 'Account'}.{api_name}"
    if metadata_type == "LightningComponentBundle" and paths:
        return paths[0].split("/lwc/", 1)[-1].split("/", 1)[0]
    return api_name


_mock_singleton: Optional[MockMetadataRetriever] = None


def get_metadata_retriever(settings: Optional[Settings] = None) -> MetadataRetriever:
    global _mock_singleton
    settings = settings or get_settings()
    provider = (settings.salesforce_retrieve_provider or "auto").lower()
    if provider == "auto":
        if settings.salesforce_provider == "cli":
            provider = "cli"
        elif repo_reader_available(settings):
            provider = "repo"
        else:
            provider = "mock"
    if provider == "cli":
        return CliMetadataRetriever(settings)
    if provider == "repo":
        return GitHubMetadataRetriever(settings)
    if _mock_singleton is None:
        _mock_singleton = MockMetadataRetriever()
    return _mock_singleton


def reset_mock_metadata_retriever() -> MockMetadataRetriever:
    global _mock_singleton
    _mock_singleton = MockMetadataRetriever()
    return _mock_singleton
