import uuid
from datetime import datetime
from typing import List

from fastapi import APIRouter, HTTPException, status, Depends, Security
from sqlalchemy import func
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session

from ...schemas.auth import UserToken
import barker.schemas.merge_move as schemas
from ...core.security import get_current_active_user as get_user
from ...db.session import SessionLocal
from ...models import Voucher, Kot, Overview, Settlement
from ...routers.voucher import (
    do_update_settlements,
    get_bill_id,
    do_update_table,
)

router = APIRouter()


# Dependency
def get_db():
    try:
        db = SessionLocal()
        yield db
    finally:
        db.close()


@router.post("/move-kot/merge")
def merge_kot(
    data: schemas.MergeKot, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["merge-kots"]),
):
    try:
        db.query(Kot).filter(Kot.id == data.kot_id).update({Kot.voucher_id: data.new_voucher_id})
        update_vouchers([data.voucher_id, data.new_voucher_id], db)
        db.commit()
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e),
        )
    except Exception:
        db.rollback()
        raise


@router.post("/move-kot/move")
def move_kot(
    data: schemas.MoveKot,
    db: Session = Depends(get_db),
    user: UserToken = Security(get_user, scopes=["move-kot-to-new-table"]),
):
    try:
        now = datetime.now()
        table_id = data.table_id

        kot = db.query(Kot).filter(Kot.id == data.kot_id).first()
        bill_id = get_bill_id(kot.voucher.voucher_type, db)
        kot_id = db.query(func.coalesce(func.max(Voucher.kot_id), 0) + 1).scalar()

        item = Voucher(
            now,
            kot.voucher.pax,
            bill_id,
            kot_id,
            table_id,
            kot.voucher.customer_id if kot.voucher.customer is not None else None,
            kot.voucher.voucher_type,
            user.id_,
        )
        db.add(item)
        item.kots.append(kot)
        do_update_table(item, None, db)
        update_vouchers([data.voucher_id, item.id], db)
        db.commit()
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e),
        )
    except Exception:
        db.rollback()
        raise


@router.post("/move-table/move")
def move_table(
    data: schemas.MoveTable, db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["move-table"]),
):
    try:
        db.query(Overview).filter(Overview.voucher_id == data.voucher_id).update(
            {Overview.food_table_id: data.table_id}
        )
        db.query(Voucher).filter(Voucher.id == data.voucher_id).update({Voucher.food_table_id: data.table_id})
        db.commit()
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e),
        )
    except Exception:
        db.rollback()
        raise


@router.post("/move-table/merge")
def merge_table(
    data: schemas.MergeTable,
    db: Session = Depends(get_db),
    user: UserToken = Security(get_user, scopes=["merge-tables"]),
):
    try:
        db.query(Kot).filter(Kot.voucher_id == data.voucher_id).update({Kot.voucher_id: data.new_voucher_id})
        db.query(Overview).filter(Overview.voucher_id == data.voucher_id).delete()
        db.query(Settlement).filter(Settlement.voucher_id == data.voucher_id).delete()
        db.query(Voucher).filter(Voucher.id == data.voucher_id).delete()
        update_vouchers([data.new_voucher_id], db)
        db.commit()
    except SQLAlchemyError as e:
        db.rollback()
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e),
        )
    except Exception:
        db.rollback()
        raise


def update_vouchers(vouchers: List[uuid.UUID], db: Session):
    for v in vouchers:
        voucher: Voucher = db.query(Voucher).filter(Voucher.id == v).first()
        do_update_settlements(voucher, [], db)