from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from sqlalchemy import and_
from typing import List, Dict, Any
from datetime import datetime
from pydantic import BaseModel

from app.db.session import get_db
from app.db.models import User, IndustryTemplate, UserIndustryTemplate, Template
from app.api.deps import get_current_user
from app.seeds.load_industry_templates import INDUSTRY_TEMPLATES_DATA

router = APIRouter(prefix="/industry-templates", tags=["industry-templates"])


# Pydantic schemas
class IndustryInfo(BaseModel):
    """Информация об индустрии"""
    industry: str
    name: str
    description: str
    templates_count: int


class IndustryTemplateOut(BaseModel):
    """Отраслевой шаблон"""
    id: int
    industry: str
    key: str
    name: str
    description: str | None
    trigger_type: str
    delay_hours: int
    content: Dict[str, str]
    variables: List[str]
    channels: List[str]
    is_active_by_default: bool
    is_editable: bool

    class Config:
        from_attributes = True


class UserTemplateOut(BaseModel):
    """Пользовательский шаблон"""
    id: int
    industry_template_id: int
    template_name: str
    trigger_type: str
    delay_hours: int
    is_active: bool
    channels: List[str]
    custom_content: Dict[str, str] | None

    class Config:
        from_attributes = True


class InstallPackageRequest(BaseModel):
    """Запрос на установку пакета"""
    industry: str


class CreateCustomTemplateRequest(BaseModel):
    """Запрос на создание кастомного шаблона"""
    name: str
    trigger_type: str
    delay_hours: int = 0
    content: Dict[str, str]
    channels: List[str]
    description: str | None = None


class UpdateTemplateRequest(BaseModel):
    """Запрос на обновление шаблона"""
    custom_name: str | None = None
    custom_content: Dict[str, str] | None = None
    custom_delay_hours: int | None = None
    channels: List[str] | None = None


# API Endpoints

@router.get("/industries", response_model=List[IndustryInfo])
def list_industries(
    db: Session = Depends(get_db),
):
    """Получить список доступных индустрий"""
    
    # Определение индустрий с фиксированным количеством шаблонов (из load_industry_templates.py)
    industry_map = {
        "medicine": {
            "name": "🏥 Медицина", 
            "description": "Напоминания о приёме, уведомления о переносе, спасибо за визит",
            "templates_count": 4  # 4 шаблона определены в load_industry_templates.py
        },
        "beauty": {
            "name": "💇 Салоны красоты", 
            "description": "Подтверждение записи, напоминания, программы лояльности",
            "templates_count": 3  # 3 шаблона
        },
        "autoservice": {
            "name": "🚗 Автосервис", 
            "description": "Заказ готов, напоминание о ТО, отзывы после визита",
            "templates_count": 3  # 3 шаблона
        },
        "delivery": {
            "name": "🍕 Доставка еды", 
            "description": "Принят заказ, курьер в пути, спасибо за заказ",
            "templates_count": 3  # 3 шаблона
        },
        "education": {
            "name": "🎓 Онлайн-школа", 
            "description": "Напоминание о занятии, ссылка на Zoom, обратная связь",
            "templates_count": 3  # 3 шаблона
        }
    }
    
    # Возвращаем все индустрии с фиксированным количеством шаблонов
    industries = []
    for industry_key, info in industry_map.items():
        industries.append(IndustryInfo(
            industry=industry_key,
            name=info["name"],
            description=info["description"],
            templates_count=info["templates_count"]
        ))
    
    return industries


@router.get("/industries/{industry}/templates", response_model=List[IndustryTemplateOut])
def get_industry_templates(
    industry: str,
    db: Session = Depends(get_db),
):
    """Получить шаблоны для индустрии"""
    templates = db.query(IndustryTemplate).filter(
        IndustryTemplate.industry == industry
    ).all()
    
    if not templates:
        raise HTTPException(status_code=404, detail=f"Шаблоны для индустрии '{industry}' не найдены")
    
    return templates


@router.post("/install-package")
def install_package(
    request: InstallPackageRequest,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """
    Установить пакет шаблонов для выбранной индустрии.
    Создаёт копии шаблонов для текущего пользователя.
    """
    
    # Проверяем, есть ли уже установленные шаблоны
    existing = db.query(UserIndustryTemplate).filter(
        UserIndustryTemplate.tenant_id == current_user.tenant_id
    ).first()
    
    if existing:
        # Получаем индустрию существующих шаблонов
        existing_template = db.query(IndustryTemplate).filter(
            IndustryTemplate.id == existing.industry_template_id
        ).first()
        
        raise HTTPException(
            status_code=400,
            detail=f"У вас уже установлен пакет для индустрии '{existing_template.industry}'. Сначала удалите существующие шаблоны."
        )
    
    # Получаем шаблоны для индустрии
    industry_templates = db.query(IndustryTemplate).filter(
        IndustryTemplate.industry == request.industry
    ).all()
    
    # Если шаблонов нет в БД, загружаем их из определения
    if not industry_templates:
        # Фильтруем шаблоны для данной индустрии из определения
        templates_to_load = [t for t in INDUSTRY_TEMPLATES_DATA if t['industry'] == request.industry]
        
        if not templates_to_load:
            raise HTTPException(
                status_code=404,
                detail=f"Шаблоны для индустрии '{request.industry}' не найдены"
            )
        
        # Загружаем шаблоны в БД
        for template_data in templates_to_load:
            # Проверяем, не существует ли уже такой шаблон (по ключу)
            existing = db.query(IndustryTemplate).filter(
                IndustryTemplate.key == template_data['key']
            ).first()
            
            if not existing:
                template = IndustryTemplate(**template_data)
                db.add(template)
        
        db.commit()
        
        # Теперь получаем загруженные шаблоны
        industry_templates = db.query(IndustryTemplate).filter(
            IndustryTemplate.industry == request.industry
        ).all()
    
    # Создаём пользовательские копии
    user_templates = []
    for ind_template in industry_templates:
        # Создаём базовый шаблон
        template = Template(
            tenant_id=current_user.tenant_id,
            name=ind_template.name,
            slug=f"{current_user.tenant_id}-{ind_template.key}",
            content=ind_template.content.get('telegram') or ind_template.content.get('email', ''),
            variables=ind_template.variables,
            channel_strategy={
                "primary": ind_template.channels,
                "failover": False
            }
        )
        db.add(template)
        db.flush()
        
        # Создаём связь с отраслевым шаблоном
        user_template = UserIndustryTemplate(
            tenant_id=current_user.tenant_id,
            industry_template_id=ind_template.id,
            template_id=template.id,
            is_active=ind_template.is_active_by_default,
            channels=ind_template.channels
        )
        db.add(user_template)
        user_templates.append(user_template)
    
    db.commit()
    
    return {
        "success": True,
        "message": f"Установлено {len(user_templates)} шаблонов для индустрии '{request.industry}'",
        "templates_count": len(user_templates),
        "industry": request.industry
    }


@router.get("/my-templates", response_model=List[UserTemplateOut])
def get_my_templates(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Получить мои установленные шаблоны"""
    user_templates = db.query(UserIndustryTemplate).filter(
        UserIndustryTemplate.tenant_id == current_user.tenant_id
    ).all()
    
    result = []
    for ut in user_templates:
        ind_template = db.query(IndustryTemplate).filter(
            IndustryTemplate.id == ut.industry_template_id
        ).first()
        
        if ind_template:
            result.append(UserTemplateOut(
                id=ut.id,
                industry_template_id=ut.industry_template_id,
                template_name=ut.custom_name or ind_template.name,
                trigger_type=ind_template.trigger_type,
                delay_hours=ut.custom_delay_hours or ind_template.delay_hours,
                is_active=ut.is_active,
                channels=ut.channels or ind_template.channels,
                custom_content=ut.custom_content
            ))
    
    return result


@router.get("/available", response_model=List[IndustryTemplateOut])
def get_available_templates(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Получить все доступные готовые шаблоны индустрии для создания триггеров"""
    # Получаем все IndustryTemplate с trigger_type (готовые шаблоны)
    industry_templates = db.query(IndustryTemplate).filter(
        IndustryTemplate.trigger_type.isnot(None)
    ).all()
    
    return industry_templates


@router.put("/my-templates/{template_id}/toggle")
def toggle_template(
    template_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Включить/выключить шаблон"""
    user_template = db.query(UserIndustryTemplate).filter(
        and_(
            UserIndustryTemplate.id == template_id,
            UserIndustryTemplate.tenant_id == current_user.tenant_id
        )
    ).first()
    
    if not user_template:
        raise HTTPException(status_code=404, detail="Шаблон не найден")
    
    user_template.is_active = not user_template.is_active
    user_template.updated_at = datetime.utcnow()
    db.commit()
    
    return {
        "success": True,
        "is_active": user_template.is_active
    }


@router.put("/my-templates/{template_id}")
def update_template(
    template_id: int,
    request: UpdateTemplateRequest,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Обновить пользовательский шаблон"""
    user_template = db.query(UserIndustryTemplate).filter(
        and_(
            UserIndustryTemplate.id == template_id,
            UserIndustryTemplate.tenant_id == current_user.tenant_id
        )
    ).first()
    
    if not user_template:
        raise HTTPException(status_code=404, detail="Шаблон не найден")
    
    # Обновляем поля
    if request.custom_name is not None:
        user_template.custom_name = request.custom_name
    if request.custom_content is not None:
        user_template.custom_content = request.custom_content
    if request.custom_delay_hours is not None:
        user_template.custom_delay_hours = request.custom_delay_hours
    if request.channels is not None:
        user_template.channels = request.channels
    
    user_template.updated_at = datetime.utcnow()
    db.commit()
    
    return {
        "success": True,
        "message": "Шаблон обновлён"
    }


@router.delete("/my-templates")
def delete_all_templates(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Удалить все мои шаблоны"""
    deleted = db.query(UserIndustryTemplate).filter(
        UserIndustryTemplate.tenant_id == current_user.tenant_id
    ).delete()
    
    db.commit()
    
    return {
        "success": True,
        "deleted_count": deleted
    }


@router.post("/my-templates/custom")
def create_custom_template(
    request: CreateCustomTemplateRequest,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Создать кастомный шаблон для текущей индустрии"""
    
    # Проверяем, что у пользователя есть установленные шаблоны
    existing = db.query(UserIndustryTemplate).filter(
        UserIndustryTemplate.tenant_id == current_user.tenant_id
    ).first()
    
    if not existing:
        raise HTTPException(
            status_code=400,
            detail="Сначала установите пакет шаблонов для индустрии"
        )
    
    # Получаем индустрию из существующих шаблонов
    existing_template = db.query(IndustryTemplate).filter(
        IndustryTemplate.id == existing.industry_template_id
    ).first()
    
    if not existing_template:
        raise HTTPException(status_code=400, detail="Индустрия не найдена")
    
    # Создаём кастомный отраслевой шаблон
    custom_industry_template = IndustryTemplate(
        industry=existing_template.industry,
        key=f"custom-{current_user.tenant_id}-{len(request.name)}",
        name=request.name,
        description=request.description,
        trigger_type=request.trigger_type,
        delay_hours=request.delay_hours,
        content=request.content,
        variables=list(set([
            var.replace('{{', '').replace('}}', '') 
            for content in request.content.values() 
            for var in content.split('{{')[1:] if '{{' in content
        ])),
        channels=request.channels,
        is_active_by_default=True,
        is_editable=True
    )
    db.add(custom_industry_template)
    db.flush()
    
    # Создаём базовый шаблон
    template = Template(
        tenant_id=current_user.tenant_id,
        name=request.name,
        slug=f"{current_user.tenant_id}-custom-{len(request.name)}",
        content=request.content.get('telegram') or request.content.get('email', ''),
        variables=custom_industry_template.variables,
        channel_strategy={
            "primary": request.channels,
            "failover": False
        }
    )
    db.add(template)
    db.flush()
    
    # Создаём связь с отраслевым шаблоном
    user_template = UserIndustryTemplate(
        tenant_id=current_user.tenant_id,
        industry_template_id=custom_industry_template.id,
        template_id=template.id,
        is_active=True,
        channels=request.channels,
        is_custom=True  # Отмечаем как кастомный
    )
    db.add(user_template)
    db.commit()
    
    return {
        "success": True,
        "message": f"Кастомный шаблон '{request.name}' создан",
        "template_id": user_template.id
    }