"""
Internal Demo Cloning API for Inventory Service
Service-to-service endpoint for cloning inventory data
"""

from fastapi import APIRouter, Depends, HTTPException, Header
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
import structlog
import uuid
from datetime import datetime, timezone
from typing import Optional
import os

from app.core.database import get_db
from app.models.inventory import Ingredient

logger = structlog.get_logger()
router = APIRouter(prefix="/internal/demo", tags=["internal"])

# Internal API key for service-to-service auth
INTERNAL_API_KEY = os.getenv("INTERNAL_API_KEY", "dev-internal-key-change-in-production")

# Base demo tenant IDs
DEMO_TENANT_SAN_PABLO = "a1b2c3d4-e5f6-47a8-b9c0-d1e2f3a4b5c6"
DEMO_TENANT_LA_ESPIGA = "b2c3d4e5-f6a7-48b9-c0d1-e2f3a4b5c6d7"


def verify_internal_api_key(x_internal_api_key: Optional[str] = Header(None)):
    """Verify internal API key for service-to-service communication"""
    if x_internal_api_key != INTERNAL_API_KEY:
        logger.warning("Unauthorized internal API access attempted")
        raise HTTPException(status_code=403, detail="Invalid internal API key")
    return True


@router.post("/clone")
async def clone_demo_data(
    base_tenant_id: str,
    virtual_tenant_id: str,
    demo_account_type: str,
    session_id: Optional[str] = None,
    db: AsyncSession = Depends(get_db),
    _: bool = Depends(verify_internal_api_key)
):
    """
    Clone inventory service data for a virtual demo tenant

    Clones:
    - Ingredients from template tenant
    - (Future: recipes, stock data, etc.)

    Args:
        base_tenant_id: Template tenant UUID to clone from
        virtual_tenant_id: Target virtual tenant UUID
        demo_account_type: Type of demo account
        session_id: Originating session ID for tracing

    Returns:
        Cloning status and record counts
    """
    start_time = datetime.now(timezone.utc)

    logger.info(
        "Starting inventory data cloning",
        base_tenant_id=base_tenant_id,
        virtual_tenant_id=virtual_tenant_id,
        demo_account_type=demo_account_type,
        session_id=session_id
    )

    try:
        # Validate UUIDs
        base_uuid = uuid.UUID(base_tenant_id)
        virtual_uuid = uuid.UUID(virtual_tenant_id)

        # Track cloning statistics
        stats = {
            "ingredients": 0,
            # Add other entities here in future
        }

        # Clone Ingredients
        result = await db.execute(
            select(Ingredient).where(Ingredient.tenant_id == base_uuid)
        )
        base_ingredients = result.scalars().all()

        logger.info(
            "Found ingredients to clone",
            count=len(base_ingredients),
            base_tenant=str(base_uuid)
        )

        for ingredient in base_ingredients:
            # Create new ingredient with same attributes but new ID and tenant
            new_ingredient = Ingredient(
                id=uuid.uuid4(),
                tenant_id=virtual_uuid,
                name=ingredient.name,
                sku=ingredient.sku,
                barcode=ingredient.barcode,
                product_type=ingredient.product_type,
                ingredient_category=ingredient.ingredient_category,
                product_category=ingredient.product_category,
                subcategory=ingredient.subcategory,
                description=ingredient.description,
                brand=ingredient.brand,
                unit_of_measure=ingredient.unit_of_measure,
                package_size=ingredient.package_size,
                average_cost=ingredient.average_cost,
                last_purchase_price=ingredient.last_purchase_price,
                standard_cost=ingredient.standard_cost,
                low_stock_threshold=ingredient.low_stock_threshold,
                reorder_point=ingredient.reorder_point,
                reorder_quantity=ingredient.reorder_quantity,
                max_stock_level=ingredient.max_stock_level,
                shelf_life_days=ingredient.shelf_life_days,
                is_perishable=ingredient.is_perishable,
                is_active=ingredient.is_active,
                allergen_info=ingredient.allergen_info
            )
            db.add(new_ingredient)
            stats["ingredients"] += 1

        # Commit all changes
        await db.commit()

        total_records = sum(stats.values())
        duration_ms = int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000)

        logger.info(
            "Inventory data cloning completed",
            virtual_tenant_id=virtual_tenant_id,
            total_records=total_records,
            stats=stats,
            duration_ms=duration_ms
        )

        return {
            "service": "inventory",
            "status": "completed",
            "records_cloned": total_records,
            "duration_ms": duration_ms,
            "details": stats
        }

    except ValueError as e:
        logger.error("Invalid UUID format", error=str(e))
        raise HTTPException(status_code=400, detail=f"Invalid UUID: {str(e)}")

    except Exception as e:
        logger.error(
            "Failed to clone inventory data",
            error=str(e),
            virtual_tenant_id=virtual_tenant_id,
            exc_info=True
        )

        # Rollback on error
        await db.rollback()

        return {
            "service": "inventory",
            "status": "failed",
            "records_cloned": 0,
            "duration_ms": int((datetime.now(timezone.utc) - start_time).total_seconds() * 1000),
            "error": str(e)
        }


@router.get("/clone/health")
async def clone_health_check(_: bool = Depends(verify_internal_api_key)):
    """
    Health check for internal cloning endpoint
    Used by orchestrator to verify service availability
    """
    return {
        "service": "inventory",
        "clone_endpoint": "available",
        "version": "2.0.0"
    }