"""Salesforce data model discovery: object/field schema for the Solution Architect."""

from __future__ import annotations

import asyncio
import json
import re
import xml.etree.ElementTree as ET
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__)

STANDARD_OBJECTS = (
    "Account",
    "Contact",
    "Opportunity",
    "Lead",
    "Case",
    "Campaign",
    "Contract",
    "Order",
    "Product2",
    "Quote",
    "Asset",
    "Task",
    "Event",
    "User",
)

_MAX_OBJECTS = 5
_MAX_REPO_FIELDS = 60
_SF_NS = "{http://soap.sforce.com/2006/04/metadata}"


class FieldInfo(BaseModel):
    name: str
    label: str = ""
    type: str = ""
    custom: bool = False
    required: bool = False
    picklist_values: List[str] = Field(default_factory=list)
    reference_to: List[str] = Field(default_factory=list)


class ObjectSchema(BaseModel):
    name: str
    label: str = ""
    custom: bool = False
    exists: bool = True
    fields: List[FieldInfo] = Field(default_factory=list)
    validation_rules: List[str] = Field(default_factory=list)
    record_types: List[str] = Field(default_factory=list)

    def field_names(self) -> set[str]:
        return {f.name.lower() for f in self.fields}


class DataModel(BaseModel):
    source: str
    objects: List[ObjectSchema] = Field(default_factory=list)
    warnings: List[str] = Field(default_factory=list)

    def get(self, name: Optional[str]) -> Optional[ObjectSchema]:
        if not name:
            return None
        for obj in self.objects:
            if obj.name.lower() == name.lower():
                return obj
        return None

    def prompt_block(self, max_fields: int = 40) -> str:
        if not self.objects:
            return "(no objects identified)"
        lines: List[str] = [f"Source: {self.source}"]
        for obj in self.objects:
            if not obj.exists:
                lines.append(f"- {obj.name}: NOT FOUND in org/repo (would be a new object)")
                continue
            custom = [f for f in obj.fields if f.custom]
            standard = [f for f in obj.fields if not f.custom]
            shown = (custom + standard)[:max_fields]
            field_bits = []
            for f in shown:
                bit = f"{f.name} ({f.type or '?'}"
                if f.picklist_values:
                    bit += f": {', '.join(f.picklist_values[:8])}"
                if f.reference_to:
                    bit += f" -> {', '.join(f.reference_to)}"
                bit += ")"
                field_bits.append(bit)
            lines.append(
                f"- {obj.name}: {len(obj.fields)} field(s), {len(custom)} custom. "
                f"Fields: {'; '.join(field_bits) or '(none listed)'}"
            )
            if obj.validation_rules:
                lines.append(f"  Validation rules: {', '.join(obj.validation_rules)}")
            if obj.record_types:
                lines.append(f"  Record types: {', '.join(obj.record_types)}")
        for w in self.warnings:
            lines.append(f"- warning: {w}")
        return "\n".join(lines)


class OrgSchemaProvider(Protocol):
    async def describe(self, objects: List[str]) -> DataModel: ...


def detect_objects(text: str) -> List[str]:
    """Pick Salesforce object names mentioned in requirement text."""
    found: List[str] = []
    for name in STANDARD_OBJECTS:
        if re.search(rf"\b{re.escape(name)}s?\b", text or "", re.IGNORECASE):
            found.append(name)
    for m in re.finditer(
        r"\b([A-Za-z][A-Za-z0-9_]*__c)\s+object\b|\bobject\s+([A-Za-z][A-Za-z0-9_]*__c)\b",
        text or "",
        re.IGNORECASE,
    ):
        name = m.group(1) or m.group(2)
        if name not in found:
            found.append(name)
    return found[:_MAX_OBJECTS]


_MOCK_STANDARD_FIELDS: Dict[str, List[FieldInfo]] = {
    "Account": [
        FieldInfo(name="Name", label="Account Name", type="string", required=True),
        FieldInfo(name="Industry", label="Industry", type="picklist",
                  picklist_values=["Agriculture", "Banking", "Technology"]),
        FieldInfo(name="AnnualRevenue", label="Annual Revenue", type="currency"),
        FieldInfo(name="OwnerId", label="Owner", type="reference", reference_to=["User"]),
    ],
    "Contact": [
        FieldInfo(name="LastName", label="Last Name", type="string", required=True),
        FieldInfo(name="Email", label="Email", type="email"),
        FieldInfo(name="AccountId", label="Account", type="reference", reference_to=["Account"]),
    ],
    "Opportunity": [
        FieldInfo(name="Name", label="Name", type="string", required=True),
        FieldInfo(name="StageName", label="Stage", type="picklist", required=True,
                  picklist_values=["Prospecting", "Closed Won", "Closed Lost"]),
        FieldInfo(name="Amount", label="Amount", type="currency"),
        FieldInfo(name="AccountId", label="Account", type="reference", reference_to=["Account"]),
    ],
    "Lead": [
        FieldInfo(name="LastName", label="Last Name", type="string", required=True),
        FieldInfo(name="Company", label="Company", type="string", required=True),
        FieldInfo(name="Status", label="Lead Status", type="picklist", required=True),
    ],
    "Case": [
        FieldInfo(name="Subject", label="Subject", type="string"),
        FieldInfo(name="Status", label="Status", type="picklist", required=True),
        FieldInfo(name="AccountId", label="Account", type="reference", reference_to=["Account"]),
    ],
}


class MockOrgSchemaProvider:
    """Static standard-object schema for local/dev and CI."""

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

    async def describe(self, objects: List[str]) -> DataModel:
        self.calls.append(list(objects))
        model = DataModel(source="mock")
        for name in objects:
            fields = list(_MOCK_STANDARD_FIELDS.get(name, [])) + list(self.extra_fields.get(name, []))
            exists = name in _MOCK_STANDARD_FIELDS or bool(self.extra_fields.get(name))
            model.objects.append(
                ObjectSchema(name=name, label=name, custom=name.endswith("__c"), exists=exists, fields=fields)
            )
        return model


class CliOrgSchemaProvider:
    """`sf sobject describe` against the lower-org alias (read-only)."""

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

    async def describe(self, objects: List[str]) -> DataModel:
        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 schema provider")
        if _looks_like_production(alias):
            raise ValueError(f"Refusing schema describe on production-like alias '{alias}'")

        model = DataModel(source=f"org:{alias}")
        for name in objects:
            proc = await asyncio.create_subprocess_exec(
                "sf", "sobject", "describe", "--sobject", name, "--target-org", alias, "--json",
                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 = {}
            result = payload.get("result") if isinstance(payload.get("result"), dict) else None
            if proc.returncode != 0 or not result:
                model.objects.append(ObjectSchema(name=name, exists=False))
                model.warnings.append(f"describe {name} failed: {payload.get('message') or 'not found'}")
                continue
            model.objects.append(_schema_from_describe(result))
        return model


def _schema_from_describe(result: dict) -> ObjectSchema:
    fields = []
    for f in result.get("fields") or []:
        fields.append(
            FieldInfo(
                name=f.get("name", ""),
                label=f.get("label", ""),
                type=f.get("type", ""),
                custom=bool(f.get("custom")),
                required=not f.get("nillable", True) and bool(f.get("createable")) and not f.get("defaultedOnCreate"),
                picklist_values=[p.get("value") for p in f.get("picklistValues") or [] if p.get("active", True)],
                reference_to=list(f.get("referenceTo") or []),
            )
        )
    return ObjectSchema(
        name=result.get("name", ""),
        label=result.get("label", ""),
        custom=bool(result.get("custom")),
        exists=True,
        fields=fields,
        record_types=[
            rt.get("developerName") or rt.get("name")
            for rt in result.get("recordTypeInfos") or []
            if not rt.get("master")
        ],
    )


class RepoOrgSchemaProvider:
    """Schema from SFDX source on GitHub (custom fields, validation rules, record types)."""

    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 describe(self, objects: List[str]) -> DataModel:
        model = DataModel(source=f"repo:{self.reader.owner}/{self.reader.repo}")
        try:
            paths = await self.reader.list_paths()
        except httpx.HTTPError as exc:
            model.warnings.append(f"repo listing failed: {exc}")
            return model

        for name in objects:
            prefix = f"force-app/main/default/objects/{name}/"
            obj_paths = [p for p in paths if p.startswith(prefix)]
            schema = ObjectSchema(
                name=name,
                label=name,
                custom=name.endswith("__c"),
                exists=bool(obj_paths) or name in STANDARD_OBJECTS,
            )
            field_paths = [p for p in obj_paths if p.endswith(".field-meta.xml")][:_MAX_REPO_FIELDS]
            for path in field_paths:
                try:
                    xml_text = await self.reader.read_file(path)
                except httpx.HTTPError:
                    xml_text = None
                schema.fields.append(_field_from_xml(xml_text, path))
            schema.validation_rules = [
                _leaf_name(p, ".validationRule-meta.xml")
                for p in obj_paths
                if p.endswith(".validationRule-meta.xml")
            ]
            schema.record_types = [
                _leaf_name(p, ".recordType-meta.xml") for p in obj_paths if p.endswith(".recordType-meta.xml")
            ]
            if name in STANDARD_OBJECTS:
                model.warnings.append(
                    f"{name}: standard fields not listed (repo source only contains customizations)"
                )
            model.objects.append(schema)
        return model


def _leaf_name(path: str, suffix: str) -> str:
    return path.rsplit("/", 1)[-1][: -len(suffix)]


def _field_from_xml(xml_text: Optional[str], path: str) -> FieldInfo:
    name = _leaf_name(path, ".field-meta.xml")
    info = FieldInfo(name=name, custom=name.endswith("__c"))
    if not xml_text:
        return info
    try:
        root = ET.fromstring(xml_text)
    except ET.ParseError:
        return info

    def text(tag: str) -> str:
        el = root.find(f"{_SF_NS}{tag}")
        if el is None:
            el = root.find(tag)
        return (el.text or "").strip() if el is not None and el.text else ""

    info.label = text("label")
    info.type = text("type")
    info.required = text("required").lower() == "true"
    ref = text("referenceTo")
    if ref:
        info.reference_to = [ref]
    values = root.findall(f".//{_SF_NS}valueSetDefinition/{_SF_NS}value/{_SF_NS}fullName") or root.findall(
        ".//valueSetDefinition/value/fullName"
    )
    info.picklist_values = [(v.text or "").strip() for v in values if v.text]
    return info


_mock_singleton: Optional[MockOrgSchemaProvider] = None


def get_org_schema_provider(settings: Optional[Settings] = None) -> OrgSchemaProvider:
    global _mock_singleton
    settings = settings or get_settings()
    provider = (settings.salesforce_schema_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 CliOrgSchemaProvider(settings)
    if provider == "repo":
        return RepoOrgSchemaProvider(settings)
    if _mock_singleton is None:
        _mock_singleton = MockOrgSchemaProvider()
    return _mock_singleton


def reset_mock_org_schema() -> MockOrgSchemaProvider:
    global _mock_singleton
    _mock_singleton = MockOrgSchemaProvider()
    return _mock_singleton
