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

from app.db.database import get_db
from app.db.models import AutoTradeRobot

router = APIRouter()

# --- Schema ---
class AutoTradeConfigSchema(BaseModel):
    id: str
    stockCode: str
    stockName: str
    groupId: Optional[str] = None
    type: str
    frequency: str
    executionTime: str
    market: str
    quantity: int
    specificDay: Optional[int] = None
    trailingPercent: Optional[float] = None
    active: bool = True
    
    class Config:
        from_attributes = True

# --- Endpoints ---
@router.get("/configs", response_model=List[AutoTradeConfigSchema])
async def get_auto_configs(db: AsyncSession = Depends(get_db)):
    stmt = select(AutoTradeRobot)
    res = await db.execute(stmt)
    return res.scalars().all()

@router.post("/configs")
async def create_auto_config(config: AutoTradeConfigSchema, db: AsyncSession = Depends(get_db)):
    # Check exists? Upsert? 
    # Frontend generates ID usually or we do. Schema has ID.
    # We will upsert (merge) or just add.
    
    # Check if exists
    stmt = select(AutoTradeRobot).where(AutoTradeRobot.id == config.id)
    res = await db.execute(stmt)
    existing = res.scalar_one_or_none()
    
    if existing:
        # Update
        existing.stockCode = config.stockCode
        existing.stockName = config.stockName
        existing.groupId = config.groupId
        existing.type = config.type
        existing.frequency = config.frequency
        existing.executionTime = config.executionTime
        existing.market = config.market
        existing.quantity = config.quantity
        existing.specificDay = config.specificDay
        existing.trailingPercent = config.trailingPercent
        existing.active = config.active
    else:
        # Create
        new_obj = AutoTradeRobot(
            id=config.id,
            stockCode=config.stockCode,
            stockName=config.stockName,
            groupId=config.groupId,
            type=config.type,
            frequency=config.frequency,
            executionTime=config.executionTime,
            market=config.market,
            quantity=config.quantity,
            specificDay=config.specificDay,
            trailingPercent=config.trailingPercent,
            active=config.active
        )
        db.add(new_obj)
        
    await db.commit()
    return {"status": "saved", "id": config.id}

@router.delete("/configs/{config_id}")
async def delete_auto_config(config_id: str, db: AsyncSession = Depends(get_db)):
    await db.execute(delete(AutoTradeRobot).where(AutoTradeRobot.id == config_id))
    await db.commit()
    return {"status": "deleted"}