from pydantic_settings import BaseSettings
from functools import lru_cache

class Settings(BaseSettings):
    PROJECT_NAME: str = "Kanban API"
    VERSION: str = "1.0.0"
    API_V1_STR: str = "/api/v1"
    
    # Database
    DATABASE_URL: str
    ASYNC_DATABASE_URL: str
    
    # Security
    SECRET_KEY: str
    ALGORITHM: str = "HS256"
    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
    REFRESH_TOKEN_EXPIRE_DAYS: int = 7
    
    model_config = SettingsConfigDict(
        env_file=".env",
        case_sensitive=True
    )

@lru_cache()
def get_settings() -> Settings:
    return Settings()

settings = get_settings()

from sqlalchemy import Column, DateTime
from sqlalchemy.sql import func

class TimeStampedModel:
    created_at = Column(DateTime, default=func.now(), nullable=False)
    updated_at = Column(DateTime, default=func.now(), 
                       onupdate=func.now(), nullable=False)

from sqlalchemy import Column, Integer, String, Boolean
from sqlalchemy.orm import relationship

class User(Base, TimeStampedModel):
    __tablename__ = "users"
    
    id = Column(Integer, primary_key=True, index=True)
    email = Column(String, unique=True, index=True, nullable=False)
    username = Column(String, unique=True, index=True, nullable=False)
    hashed_password = Column(String, nullable=False)
    is_active = Column(Boolean, default=True)
    
    # Relaciones
    boards = relationship("Board", back_populates="owner", 
                         cascade="all, delete-orphan")

class Board(Base, TimeStampedModel):
    __tablename__ = "boards"
    
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(200), nullable=False)
    description = Column(Text, nullable=True)
    owner_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    
    owner = relationship("User", back_populates="boards")
    lists = relationship("List", back_populates="board", 
                        cascade="all, delete-orphan")

class List(Base, TimeStampedModel):
    __tablename__ = "lists"
    
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(100), nullable=False)
    position = Column(Integer, default=0)  # Para ordenar
    board_id = Column(Integer, ForeignKey("boards.id"), nullable=False)
    
    board = relationship("Board", back_populates="lists")
    tasks = relationship("Task", back_populates="list", 
                        cascade="all, delete-orphan")

class TaskPriority(str, enum.Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    URGENT = "urgent"

class Task(Base, TimeStampedModel):
    __tablename__ = "tasks"
    
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(200), nullable=False)
    description = Column(Text, nullable=True)
    position = Column(Integer, default=0)
    priority = Column(Enum(TaskPriority), default=TaskPriority.MEDIUM)
    list_id = Column(Integer, ForeignKey("lists.id"), nullable=False)
    
    list = relationship("List", back_populates="tasks")

from pydantic import BaseModel, Field
from datetime import datetime

class BoardBase(BaseModel):
    title: str = Field(..., min_length=1, max_length=200)
    description: str | None = None

class BoardCreate(BoardBase):
    pass

class BoardUpdate(BaseModel):
    title: str | None = Field(None, min_length=1, max_length=200)
    description: str | None = None

class BoardResponse(BoardBase):
    id: int
    owner_id: int
    created_at: datetime
    updated_at: datetime
    
    model_config = {"from_attributes": True}

from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

def verify_password(plain: str, hashed: str) -> bool:
    return pwd_context.verify(plain, hashed)

def get_password_hash(password: str) -> str:
    return pwd_context.hash(password)

from jose import jwt
from datetime import datetime, timedelta

def create_access_token(data: dict) -> str:
    to_encode = data.copy()
    expire = datetime.utcnow() + timedelta(
        minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES
    )
    to_encode.update({"exp": expire, "type": "access"})
    
    return jwt.encode(
        to_encode, 
        settings.SECRET_KEY, 
        algorithm=settings.ALGORITHM
    )

from typing import Generic, TypeVar, Type, List, Optional
from pydantic import BaseModel
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

ModelType = TypeVar("ModelType")
CreateSchemaType = TypeVar("CreateSchemaType", bound=BaseModel)
UpdateSchemaType = TypeVar("UpdateSchemaType", bound=BaseModel)

class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
    def __init__(self, model: Type[ModelType]):
        self.model = model
    
    async def get(self, db: AsyncSession, id: int) -> Optional[ModelType]:
        result = await db.execute(
            select(self.model).filter(self.model.id == id)
        )
        return result.scalars().first()
    
    async def get_multi(
        self, db: AsyncSession, skip: int = 0, limit: int = 100
    ) -> List[ModelType]:
        result = await db.execute(
            select(self.model).offset(skip).limit(limit)
        )
        return result.scalars().all()
    
    async def create(
        self, db: AsyncSession, obj_in: CreateSchemaType
    ) -> ModelType:
        obj_in_data = jsonable_encoder(obj_in)
        db_obj = self.model(**obj_in_data)
        db.add(db_obj)
        await db.commit()
        await db.refresh(db_obj)
        return db_obj
    
    async def update(
        self, db: AsyncSession, db_obj: ModelType, obj_in: UpdateSchemaType
    ) -> ModelType:
        update_data = obj_in.model_dump(exclude_unset=True)
        for field, value in update_data.items():
            setattr(db_obj, field, value)
        
        db.add(db_obj)
        await db.commit()
        await db.refresh(db_obj)
        return db_obj
    
    async def remove(self, db: AsyncSession, id: int) -> ModelType:
        obj = await self.get(db, id)
        await db.delete(obj)
        await db.commit()
        return obj

class CRUDUser(CRUDBase[User, UserCreate, UserResponse]):
    async def get_by_email(
        self, db: AsyncSession, email: str
    ) -> Optional[User]:
        result = await db.execute(
            select(User).filter(User.email == email)
        )
        return result.scalars().first()
    
    async def create(
        self, db: AsyncSession, obj_in: UserCreate
    ) -> User:
        db_obj = User(
            email=obj_in.email,
            username=obj_in.username,
            hashed_password=get_password_hash(obj_in.password)
        )
        db.add(db_obj)
        await db.commit()
        await db.refresh(db_obj)
        return db_obj
    
    async def authenticate(
        self, db: AsyncSession, email: str, password: str
    ) -> Optional[User]:
        user = await self.get_by_email(db, email=email)
        if not user or not verify_password(password, user.hashed_password):
            return None
        return user

user = CRUDUser(User)

@router.post("/", response_model=BoardResponse, status_code=201)
async def create_board(
    *,
    db: AsyncSession = Depends(get_db),
    board_in: BoardCreate,
    current_user: User = Depends(get_current_active_user)
) -> BoardResponse:
    """Crear un nuevo tablero"""
    board = await board_crud.create_with_owner(
        db, obj_in=board_in, owner_id=current_user.id
    )
    return board

@router.get("/", response_model=List[BoardResponse])
async def list_boards(
    db: AsyncSession = Depends(get_db),
    skip: int = Query(0, ge=0),
    limit: int = Query(100, ge=1, le=100),
    current_user: User = Depends(get_current_active_user)
) -> List[BoardResponse]:
    """Listar tableros del usuario actual"""
    boards = await board_crud.get_by_owner(
        db, owner_id=current_user.id, skip=skip, limit=limit
    )
    return boards

@router.post("/{task_id}/move", response_model=TaskResponse)
async def move_task(
    task_id: int,
    move_data: TaskMove,
    db: AsyncSession = Depends(get_db),
    current_user: User = Depends(get_current_active_user)
) -> TaskResponse:
    """Mover tarea a otra lista (cambiar estado)"""
    
    # Obtener tarea
    task = await task_crud.get(db, id=task_id)
    if not task:
        raise NotFoundException("Task not found")
    
    # Verificar permisos
    await verify_list_permission(db, task.list_id, current_user.id)
    await verify_list_permission(db, move_data.list_id, current_user.id)
    
    # Mover tarea
    task = await task_crud.move_to_list(
        db, task=task, 
        list_id=move_data.list_id, 
        position=move_data.position
    )
    return task

from app.core.config import settings
from app.db.session import Base
from app.db.models.user import User
from app.db.models.board import Board
from app.db.models.list import List
from app.db.models.task import Task

config.set_main_option('sqlalchemy.url', settings.DATABASE_URL)
target_metadata = Base.metadata

def upgrade() -> None:
    op.add_column('users', 
        sa.Column('avatar_url', sa.String(), nullable=True)
    )

def downgrade() -> None:
    op.drop_column('users', 'avatar_url')

import pytest
from httpx import AsyncClient
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from app.main import app
from app.db.session import get_db, Base

TEST_DATABASE_URL = "sqlite+aiosqlite:///./test.db"

@pytest.fixture
async def client() -> AsyncClient:
    engine = create_async_engine(TEST_DATABASE_URL)
    
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
    
    async def override_get_db():
        async with AsyncSession(engine) as session:
            yield session
    
    app.dependency_overrides[get_db] = override_get_db
    
    async with AsyncClient(app=app, base_url="http://test") as ac:
        yield ac
    
    app.dependency_overrides.clear()

@pytest.mark.asyncio
async def test_register_and_login(client: AsyncClient):
    # Registro
    register_data = {
        "email": "test@example.com",
        "username": "testuser",
        "password": "Test1234"
    }
    response = await client.post("/api/v1/auth/register", json=register_data)
    assert response.status_code == 201
    
    # Login
    login_data = {
        "username": "test@example.com",
        "password": "Test1234"
    }
    response = await client.post("/api/v1/auth/login", data=login_data)
    assert response.status_code == 200
    assert "access_token" in response.json()