from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select, update, delete
from typing import List
from datetime import datetime

from app.core.database import get_db
from app.models.models import TradingRule
from pydantic import BaseModel

router = APIRouter()


class TradingRuleCreate(BaseModel):
    name: str
    description: str = None
    rule_type: str
    conditions: dict
    actions: dict
    is_active: bool = True
    priority: int = 0


class TradingRuleUpdate(BaseModel):
    name: str = None
    description: str = None
    rule_type: str = None
    conditions: dict = None
    actions: dict = None
    is_active: bool = None
    priority: int = None


class TradingRuleResponse(BaseModel):
    id: int
    name: str
    description: str = None
    rule_type: str
    conditions: dict
    actions: dict
    is_active: bool
    priority: int
    created_at: datetime
    updated_at: datetime
    
    class Config:
        from_attributes = True


@router.get("", response_model=List[TradingRuleResponse])
async def get_trading_rules(
    skip: int = 0,
    limit: int = 100,
    is_active: bool = None,
    db: AsyncSession = Depends(get_db)
):
    """트레이딩 규칙 목록 조회"""
    query = select(TradingRule)
    
    if is_active is not None:
        query = query.where(TradingRule.is_active == is_active)
    
    query = query.order_by(TradingRule.priority.desc(), TradingRule.created_at.desc())
    query = query.offset(skip).limit(limit)
    
    result = await db.execute(query)
    rules = result.scalars().all()
    return rules


@router.get("/{rule_id}", response_model=TradingRuleResponse)
async def get_trading_rule(rule_id: int, db: AsyncSession = Depends(get_db)):
    """특정 트레이딩 규칙 조회"""
    result = await db.execute(select(TradingRule).where(TradingRule.id == rule_id))
    rule = result.scalar_one_or_none()
    
    if not rule:
        raise HTTPException(status_code=404, detail="Trading rule not found")
    
    return rule


@router.post("", response_model=TradingRuleResponse)
async def create_trading_rule(rule: TradingRuleCreate, db: AsyncSession = Depends(get_db)):
    """새 트레이딩 규칙 생성"""
    db_rule = TradingRule(**rule.model_dump())
    db.add(db_rule)
    await db.commit()
    await db.refresh(db_rule)
    return db_rule


@router.put("/{rule_id}", response_model=TradingRuleResponse)
async def update_trading_rule(
    rule_id: int,
    rule: TradingRuleUpdate,
    db: AsyncSession = Depends(get_db)
):
    """트레이딩 규칙 수정"""
    result = await db.execute(select(TradingRule).where(TradingRule.id == rule_id))
    db_rule = result.scalar_one_or_none()
    
    if not db_rule:
        raise HTTPException(status_code=404, detail="Trading rule not found")
    
    update_data = rule.model_dump(exclude_unset=True)
    for field, value in update_data.items():
        setattr(db_rule, field, value)
    
    db_rule.updated_at = datetime.utcnow()
    await db.commit()
    await db.refresh(db_rule)
    return db_rule


@router.delete("/{rule_id}")
async def delete_trading_rule(rule_id: int, db: AsyncSession = Depends(get_db)):
    """트레이딩 규칙 삭제"""
    result = await db.execute(select(TradingRule).where(TradingRule.id == rule_id))
    db_rule = result.scalar_one_or_none()
    
    if not db_rule:
        raise HTTPException(status_code=404, detail="Trading rule not found")
    
    await db.delete(db_rule)
    await db.commit()
    return {"message": "Trading rule deleted successfully"}


@router.post("/{rule_id}/toggle")
async def toggle_trading_rule(rule_id: int, db: AsyncSession = Depends(get_db)):
    """트레이딩 규칙 활성화/비활성화 토글"""
    result = await db.execute(select(TradingRule).where(TradingRule.id == rule_id))
    db_rule = result.scalar_one_or_none()
    
    if not db_rule:
        raise HTTPException(status_code=404, detail="Trading rule not found")
    
    db_rule.is_active = not db_rule.is_active
    db_rule.updated_at = datetime.utcnow()
    await db.commit()
    await db.refresh(db_rule)
    return db_rule