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

from app.db.session import get_db
from app.db.models import User, VkGroup
from app.api.deps import get_current_user
from app.utils.encryption import encrypt_token, decrypt_token


router = APIRouter(prefix="/vk-groups", tags=["vk-groups"])


class VkGroupCreate(BaseModel):
    name: str
    group_id: str
    access_token: str


class VkGroupResponse(BaseModel):
    id: int
    name: str
    group_id: str
    status: str
    created_at: datetime
    
    class Config:
        from_attributes = True


@router.get("", response_model=List[VkGroupResponse])
def list_vk_groups(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Получить список VK групп пользователя"""
    vk_groups = db.query(VkGroup).filter(
        VkGroup.tenant_id == current_user.tenant_id
    ).order_by(VkGroup.created_at.desc()).all()
    
    return vk_groups


@router.post("", response_model=VkGroupResponse, status_code=status.HTTP_201_CREATED)
def create_vk_group(
    request: VkGroupCreate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Создать новую VK группу"""
    
    # Проверяем уникальность group_id в рамках тенанта
    existing = db.query(VkGroup).filter(
        and_(
            VkGroup.tenant_id == current_user.tenant_id,
            VkGroup.group_id == request.group_id
        )
    ).first()
    
    if existing:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"VK группа с ID '{request.group_id}' уже существует"
        )
    
    # Шифруем access token
    try:
        encrypted_token = encrypt_token(request.access_token)
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Ошибка шифрования токена: {str(e)}"
        )
    
    # Создаём VK группу
    vk_group = VkGroup(
        tenant_id=current_user.tenant_id,
        name=request.name,
        group_id=request.group_id,
        access_token_enc=encrypted_token,
        status="active"
    )
    
    db.add(vk_group)
    db.commit()
    db.refresh(vk_group)
    
    return vk_group


@router.delete("/{group_id}", status_code=status.HTTP_200_OK)
def delete_vk_group(
    group_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Удалить VK группу"""
    
    vk_group = db.query(VkGroup).filter(
        and_(
            VkGroup.id == group_id,
            VkGroup.tenant_id == current_user.tenant_id
        )
    ).first()
    
    if not vk_group:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="VK группа не найдена"
        )
    
    db.delete(vk_group)
    db.commit()
    
    return {"success": True, "message": "VK группа удалена"}


@router.get("/{group_id}", response_model=VkGroupResponse)
def get_vk_group(
    group_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
):
    """Получить информацию о VK группе"""
    
    vk_group = db.query(VkGroup).filter(
        and_(
            VkGroup.id == group_id,
            VkGroup.tenant_id == current_user.tenant_id
        )
    ).first()
    
    if not vk_group:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="VK группа не найдена"
        )
    
    return vk_group