import sys
from typing import Annotated

from fastapi import APIRouter, Query, Depends
from sqlmodel import SQLModel, Field
from sqlmodel import select

import alchemy
import utils
from dependencies import get_session
from utils import update_item, create_item
from .status_model import Status
from .user import ACTIVE_USER
from .contact import Contact
from .country import Country


PRIMARY_ANNOTATION = utils.make_primary_annotation('Location Code')


# ----------------------------------------------------------------
# Models


class LocationCodeBase(SQLModel):
    code: str = Field(max_length=8, unique=True)
    description: str = Field(max_length=256)
    notes: str | None


class LocationCode(LocationCodeBase):
    id: int | None = Field(default=None, primary_key=True)
    country: Country
    contact: Contact | None = None


class LocationCodeCreate(LocationCodeBase):
    country_id: int
    contact_id : int | None = None
    notes: str | None = None


class LocationCodePublic(LocationCode):
    status: Status


class LocationCodeUpdate(LocationCodeBase):
    code: str | None = None
    description: str | None = None
    country_id: int | None = None
    contact_id: int | None = None
    notes: str | None = None


# ----------------------------------------------------------------
# Routes

router = APIRouter(prefix="/location_code", tags=["location_code"])


@router.get("/", response_model=list[LocationCodePublic])
async def get_location_codes(
        offset: int = 0,
        limit: Annotated[int, Query] = 100,
        session=Depends(get_session)):
    """Get list of all location codes"""
    if limit < 1:
        limit = sys.maxsize
    return session.exec(select(alchemy.LocationCode).offset(offset).limit(limit)).all()


@router.get("/{location_code_id}",
            response_model=LocationCodePublic,
            responses={404: {"description": "Not found"}})
async def get_location_code(
        location_code_id: PRIMARY_ANNOTATION,
        session=Depends(get_session)):
    return utils.get_single_record(session, alchemy.LocationCode, location_code_id)


@router.post("/",
             response_model=LocationCodePublic)
async def create_location_code(
        location_code: LocationCodeCreate,
        current_user: ACTIVE_USER,
        session=Depends(get_session)):
    return create_item(
        session=session,
        cls=alchemy.LocationCode,
        current_user=current_user,
        data=LocationCodeCreate.model_validate(location_code))


@router.patch("/{location_code_id}",
              response_model=LocationCodePublic,
              responses={404: {"description": "Not found"}})
async def update_location_code(
        location_code_id: PRIMARY_ANNOTATION,
        location_code: LocationCodeUpdate,
        current_user: ACTIVE_USER,
        session=Depends(get_session)):
    return update_item(
        session=session,
        current_user=current_user,
        item=utils.get_single_record(session, alchemy.LocationCode, location_code_id),
        data=location_code)


@router.put("/{location_code_id}/activate",
            response_model=LocationCodePublic,
              responses={404: {"description": "Not found"}})
async def activate_location_code(
        locationCode_id: PRIMARY_ANNOTATION,
        current_user: ACTIVE_USER,
        session=Depends(get_session)):
    return utils.set_item_status(
        session=session,
        current_user=current_user,
        item=utils.get_single_record(session, alchemy.LocationCode, locationCode_id),
        status='A')


@router.put("/{location_code_id}/deactivate",
            response_model=LocationCodePublic,
              responses={404: {"description": "Not found"}})
async def deactivate_location_code(
        location_code_id: PRIMARY_ANNOTATION,
        current_user: ACTIVE_USER,
        session=Depends(get_session)):
    return utils.set_item_status(
        session=session,
        current_user=current_user,
        item=utils.get_single_record(session, alchemy.LocationCode, location_code_id),
        status='I')