import logging
import datetime
from typing import Optional
from sqlalchemy.orm import Session

from app.models import Package, PackageRevision, Domain

logger = logging.getLogger(__name__)


def save_package_from_orchestrator(
    db: Session,
    domain_id: int,
    domain_name: str,
    orchestrator_output: dict,
) -> int:
    domain = db.query(Domain).filter(Domain.id == domain_id).first()
    if not domain:
        raise ValueError(f"Domain ID {domain_id} not found")

    blueprint_data = orchestrator_output.get("blueprint", {})
    theme_data = orchestrator_output.get("theme", {})
    valuation_data = orchestrator_output.get("valuation", {})
    validator_data = orchestrator_output.get("validator", {})

    niche_name = _extract_niche_name(valuation_data, orchestrator_output)

    site_copy = _build_site_copy(blueprint_data, theme_data)

    brand = _build_brand(theme_data, orchestrator_output)

    package = Package(
        domain_id=domain_id,
        domain_name=domain_name,
        chosen_niche=niche_name,
        brand=brand,
        site_copy=site_copy,
        template_type="hero",
        layout_style="single-scroll",
        density="balanced",
    )
    db.add(package)
    db.flush()

    revision = PackageRevision(
        package_id=package.id,
        revision_type="generation",
        action="aura_core_orchestrate",
        description="Package generated via aura_core orchestrator pipeline",
        after_data={
            "blueprint": blueprint_data,
            "theme": _safe_theme_summary(theme_data),
            "valuation": _safe_valuation_summary(valuation_data),
            "validator": validator_data,
            "meta": orchestrator_output.get("_meta", {}),
        },
    )
    db.add(revision)
    db.commit()
    db.refresh(package)

    logger.info(f"Persisted orchestrator output as Package #{package.id} for domain '{domain_name}'")
    return package.id


def _extract_niche_name(valuation_data: dict, full_output: dict) -> str:
    if isinstance(valuation_data, dict):
        niches = valuation_data.get("niche_valuations", [])
        if niches and isinstance(niches, list) and len(niches) > 0:
            return niches[0].get("niche_name", "General")
    return "General"


def _build_site_copy(blueprint_data: dict, theme_data: dict) -> dict:
    site_copy = {}
    if isinstance(blueprint_data, dict):
        bp = blueprint_data.get("blueprint", blueprint_data)
        sections = bp.get("sections", [])
        if isinstance(sections, list):
            for section in sections:
                if isinstance(section, dict):
                    key = section.get("type", section.get("key", ""))
                    if key:
                        site_copy[key] = {
                            "label": section.get("label", key),
                            "fields": section.get("fields", []),
                            "ai_instructions": section.get("ai_instructions", ""),
                            "priority": section.get("priority", 3),
                        }
    return site_copy


def _build_brand(theme_data: dict, full_output: dict) -> dict:
    brand = {}
    if isinstance(theme_data, dict):
        colors = theme_data.get("colors", {})
        if isinstance(colors, dict):
            brand["color_primary"] = colors.get("primary", "#4F46E5")
            brand["color_secondary"] = colors.get("secondary", "#7C3AED")
            brand["color_accent"] = colors.get("accent", "#06B6D4")
        brand["mood"] = theme_data.get("mood", "professional")
        css_vars = theme_data.get("css_variables", {})
        if css_vars:
            brand["css_variables"] = css_vars
    return brand


def _safe_theme_summary(theme_data: dict) -> dict:
    if not isinstance(theme_data, dict):
        return {}
    return {
        "mood": theme_data.get("mood", ""),
        "colors": theme_data.get("colors", {}),
        "card_style": theme_data.get("card_style", ""),
        "section_backgrounds": theme_data.get("section_backgrounds", {}),
    }


def _safe_valuation_summary(valuation_data: dict) -> dict:
    if not isinstance(valuation_data, dict):
        return {}
    return {
        "domain": valuation_data.get("domain", ""),
        "domain_only_value": valuation_data.get("domain_only_value", 0),
        "best_developed_value": valuation_data.get("best_developed_value", 0),
        "best_monthly_net": valuation_data.get("best_monthly_net", 0),
        "niches_evaluated": valuation_data.get("niches_evaluated", 0),
    }