import datetime
#from datetime import datetime, time, timedelta
from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, status
from pydantic import BaseModel, EmailStr, Field
from typing import Dict, List, Optional, Set, Union

from ..lib_general import *
from ..log import *
from app.config import settings
from app.db_sql import *

from .api_crud import delete_obj_template, get_obj_template, get_obj_li_template, patch_obj_template, post_obj_template

from ..models.response_model import *
from ..models.order_model import Order_Base
from ..models.order_methods import load_order_obj, save_order_obj


router = APIRouter()


@router.post('', response_model=Resp_Body_Base)
async def post_order_obj(
        obj: Order_Base,
        x_account_id: str = Header(...),
        return_obj: Optional[bool] = True,
        by_alias: Optional[bool] = True,
        exclude_unset: Optional[bool] = True,
        ):
    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    obj_type = 'order'
    obj_data_dict = obj.dict(by_alias=False, exclude_unset=True)
    result = post_obj_template(
        obj_type=obj_type,
        data=obj_data_dict,
        return_obj=True,
        by_alias=True,
        exclude_unset=True,
        )
    return result


@router.patch('/{obj_id}', response_model=Resp_Body_Base)
async def patch_order_obj(
        obj_id: str = Query(..., min_length=1, max_length=22),
        obj: Order_Base = None,
        x_account_id: Optional[str] = Header(..., ),
        return_obj: Optional[bool] = True,
        by_alias: Optional[bool] = True,
        exclude_unset: Optional[bool] = True,
        ):
    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    obj_type = 'order'
    obj_data_dict = obj.dict(by_alias=False, exclude_unset=True)
    obj_data_dict['id'] = redis_lookup_id_random(record_id_random=obj_id, table_name=obj_type)
    obj_data_dict['id_random'] = obj_id
    result = patch_obj_template(
        obj_type=obj_type,
        data=obj_data_dict,
        obj_id=obj_id,
        return_obj=True,
        by_alias=True,
        exclude_unset=True,
        )
    return result


@router.get('/list', response_model=Resp_Body_Base)
async def get_order_obj_li(
        for_obj_type: Optional[str] = Query(None, min_length=2, max_length=50),
        for_obj_id: Optional[str] = Query(None, min_length=1, max_length=22),
        order_status: Optional[str] = 'complete',
        from_datetime: Optional[datetime.datetime] = None,
        to_datetime: Optional[datetime.datetime] = None,
        limit: Optional[int] = None,
        inc_order_line_li: Optional[bool] = False,
        inc_order_cfg: Optional[bool] = False,
        inc_person_obj: Optional[bool] = False,
        inc_user_obj: Optional[bool] = False,
        x_account_id: str = Header(...),
        by_alias: Optional[bool] = True,
        exclude_unset: Optional[bool] = True,
        ):
    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    # obj_type = 'order'
    # result = get_obj_li_template(
    #     obj_type=obj_type,
    #     for_obj_type=for_obj_type,
    #     for_obj_id=for_obj_id,
    #     by_alias=True,
    #     exclude_unset=True,
    #     )
    # return result

    data = {}
    if for_obj_type == 'account' and for_obj_id:
        data['account_id'] = redis_lookup_id_random(record_id_random=for_obj_id, table_name='account')
        sql_account_person_user = f"""`order`.account_id = :account_id"""
    elif for_obj_type == 'person' and for_obj_id:
        data['person_id'] = redis_lookup_id_random(record_id_random=for_obj_id, table_name='person')
        sql_account_person_user = f"""`order`.person_id = :person_id"""
    elif for_obj_type == 'user' and for_obj_id:
        data['user_id'] = redis_lookup_id_random(record_id_random=for_obj_id, table_name='user')
        sql_account_person_user = f"""`order`.user_id = :user_id"""
    else:
        sql_account_person_user = ''

    if order_status in ['canceled', 'complete', 'in progress', 'started']:
        data['status'] = order_status
        sql_status = f"""AND `order`.status = :status"""
    else:
        sql_status = ''

    if from_datetime and to_datetime:
        data['from_datetime'] = from_datetime
        data['to_datetime'] = to_datetime
        sql_from_to_datetime = f"""AND `order`.created_on >= :from_datetime AND `order`.created_on <= :to_datetime"""
    elif from_datetime:
        data['from_datetime'] = from_datetime
        sql_from_to_datetime = f"""AND `order`.created_on >= :from_datetime"""
    elif to_datetime:
        data['to_datetime'] = to_datetime
        sql_from_to_datetime = f"""AND `order`.created_on <= :to_datetime"""
    else:
        sql_from_to_datetime = ''

    if limit:
        data['limit'] = limit
        sql_limit = f"""LIMIT :limit"""
    else:
        sql_limit = ''

    sql = f"""
        SELECT `order`.id AS 'order_id', `order`.id_random AS 'order_id_random'
        FROM `order` AS `order`
        WHERE {sql_account_person_user}
        {sql_status}
        {sql_from_to_datetime}
        ORDER BY `order`.created_on DESC, `order`.updated_on DESC
        {sql_limit};
        """

    if order_obj_li_result := sql_select(data=data, sql=sql, as_list=True):
        order_obj_li = []
        for order_obj in order_obj_li_result:
            order_id = order_obj.get('order_id', None)
            if order_obj := load_order_obj(order_id=order_id, inc_order_line_li=inc_order_line_li, inc_order_cfg=inc_order_cfg, inc_person_obj=inc_person_obj, inc_user_obj=inc_user_obj):
                data = order_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset)
                order_obj_li.append(data)
        return mk_resp(data=order_obj_li)
    else:
        log.debug(order_obj_li_result)
        return mk_resp(data=False, status_code=404)


@router.get('/{obj_id}', response_model=Resp_Body_Base)
async def get_order_obj(
        obj_id: str = Query(..., min_length=1, max_length=22),
        x_account_id: str = Header(...),
        by_alias: Optional[bool] = True,
        exclude_unset: Optional[bool] = True,
        ):
    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    obj_type = 'order'
    result = get_obj_template(
        obj_type=obj_type,
        obj_id=obj_id,
        by_alias=True,
        exclude_unset=True,
        )
    return result


@router.delete('/{obj_id}', response_model=Resp_Body_Base)
async def delete_order_obj(
        obj_id: str = Query(..., min_length=1, max_length=22),
        x_account_id: str = Header(...),
        ):
    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    obj_type = 'order'
    result = delete_obj_template(
        obj_type=obj_type,
        obj_id=obj_id,
        )
    return result