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

from app.lib_general import log, logging
from app.config import settings
from app.db_sql import sql_insert, sql_update, sql_insert_or_update, sql_select, sql_delete, redis_lookup_id_random

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

from app.methods.event_methods import get_event_rec_list, get_event_meeting_rec_list, load_event_obj, update_event_obj

from app.models.event_models import Event_Base, Event_Meeting_Flat_Base
from app.models.response_models import Resp_Body_Base, mk_resp


router = APIRouter()


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

    obj_type = 'event'
    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


# ### BEGIN ### API Event ### patch_event() ###
# Updated 2021-09-28
@router.patch('/event/{event_id}', response_model=Resp_Body_Base)
async def patch_event(
        event_obj: Event_Base,
        event_id: str = Path(min_length=11, max_length=22),
        create_sub_obj: bool = False,
        x_account_id: Optional[str] = Header(..., ),
        return_obj: Optional[bool] = True,
        inc_event_cfg: bool = False,
        by_alias: Optional[bool] = True,
        exclude_unset: Optional[bool] = True,
        exclude_none: Optional[bool] = True,
        response: Response = Response,
        ):
    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    if event_id := redis_lookup_id_random(record_id_random=event_id, table_name='event'): pass
    else: return mk_resp(data=None, status_code=404, response=response)

    if event_obj_up_result := update_event_obj(
        event_id = event_id,
        event_obj_up = event_obj,
        create_sub_obj = create_sub_obj,
        ):

        log.debug(event_obj_up_result)
        if return_obj:
            event_obj = load_event_obj(event_id=event_id, inc_event_cfg=inc_event_cfg)
            event_dict = event_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset)
            return mk_resp(data=event_dict, response=response)
        else:
            return mk_resp(data=event_obj_up_result, response=response)
    else:
        return mk_resp(data=False, status_code=400, response=response) # Bad Request
# ### END ### API Event ### patch_event() ###


# ### BEGIN ### API Event ### get_event_obj_li() ###
# Updated 2021-09-28
@router.get('/event/list', response_model=Resp_Body_Base)
async def get_event_obj_li(
        for_obj_type: Optional[str] = Query(None, min_length=2, max_length=50), # account
        for_obj_id: Optional[str] = Query(None, min_length=1, max_length=22),
        enabled: str = 'enabled', # enabled, disabled, all
        from_datetime: Optional[datetime.datetime] = None, # based on start_datetime
        to_datetime: Optional[datetime.datetime] = None, # based on start_datetime
        limit: int = None,
        inc_event_abstract_list: bool = False,
        inc_event_badge_list: bool = False,
        inc_event_cfg: bool = False,
        inc_event_device_list: bool = False,
        inc_event_exhibit_list: bool = False,
        inc_event_file_list: bool = False,
        inc_event_location_list: bool = False,
        inc_event_person_list: bool = False,
        inc_event_presentation_list: bool = False,
        inc_event_presenter_list: bool = False,
        inc_event_registration_cfg: bool = False,
        inc_event_registration_list: bool = False,
        inc_event_session_list: bool = False,
        inc_event_track_list: bool = False,
        inc_poc_event_person: bool = False,
        inc_poc_person: bool = False,
        # inc_user: bool = False,
        x_account_id: str = Header(...),
        by_alias: bool = True,
        exclude_unset: bool = True,
        response: Response = Response,
        ):
    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    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_for_obj_type_id = f'`event`.account_id = :account_id'
    # elif for_obj_type == 'test' and for_obj_id:
    #     data['test_id'] = redis_lookup_id_random(record_id_random=for_obj_id, table_name='test')
    #     sql_for_obj_type_id = f'`test`.test_id = :test_id'
    else:
        sql_for_obj_type_id = ''
        return mk_resp(data=False, status_code=400, response=response)

    if enabled in ['enabled', 'disabled', 'all']:
        if enabled == 'enabled':
            data['enable'] = True
            sql_enabled = f'AND `event`.enable = :enable'
        elif enabled == 'disabled':
            data['enable'] = False
            sql_enabled = f'AND `event`.enable = :enable'
        elif enabled == 'all':
            sql_enabled = ''
    else:
        return mk_resp(data=False, status_code=400, response=response)

    if from_datetime and to_datetime:
        data['from_datetime'] = from_datetime
        data['to_datetime'] = to_datetime
        sql_from_to_datetime = f'AND `event`.start_datetime >= :from_datetime AND `event`.start_datetime <= :to_datetime'
    elif from_datetime:
        data['from_datetime'] = from_datetime
        sql_from_to_datetime = f'AND `event`.start_datetime >= :from_datetime'
    elif to_datetime:
        data['to_datetime'] = to_datetime
        sql_from_to_datetime = f'AND `event`.start_datetime <= :to_datetime'
    else:
        sql_from_to_datetime = ''

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

    sql = f"""
        SELECT `event`.id AS 'event_id', `event`.id_random AS 'event_id_random'
        FROM `event` AS `event`
        WHERE {sql_for_obj_type_id}
        {sql_enabled}
        {sql_from_to_datetime}
        ORDER BY `event`.created_on DESC, `event`.updated_on DESC
        {sql_limit};
        """

    if event_obj_li_result := sql_select(data=data, sql=sql, as_list=True):
        log.debug(event_obj_li_result)
        event_obj_li = []
        for event_obj in event_obj_li_result:
            event_id = event_obj.get('event_id', None)
            if event_obj := load_event_obj(
                event_id = event_id,
                enabled = enabled,
                inc_event_abstract_list = inc_event_abstract_list,
                inc_event_badge_list = inc_event_badge_list,
                inc_event_device_list = inc_event_device_list,
                inc_event_exhibit_list = inc_event_exhibit_list,
                inc_event_file_list = inc_event_file_list,
                inc_event_location_list = inc_event_location_list,
                inc_event_person_list = inc_event_person_list,
                inc_event_presentation_list = inc_event_presentation_list,
                inc_event_presenter_list = inc_event_presenter_list,
                inc_event_registration_list = inc_event_registration_list,
                inc_event_session_list = inc_event_session_list,
                inc_event_track_list = inc_event_track_list,
                inc_event_cfg = inc_event_cfg,
                inc_event_registration_cfg = inc_event_registration_cfg,
                inc_poc_event_person = inc_poc_event_person,
                # inc_poc_person = inc_poc_person,
                # inc_user = inc_user,
                ):

                data = event_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
                event_obj_li.append(data)
        return mk_resp(data=event_obj_li, response=response)
    else:
        log.debug(event_obj_li_result)
        return mk_resp(data=False, status_code=404, response=response)
# ### END ### API Event ### get_event_obj_li() ###


# ### BEGIN ### API Event ### get_event_obj() ###
# Updated 2021-12-13
@router.get('/event/{event_id}', response_model=Resp_Body_Base)
async def get_event_obj(
        event_id: str = Path(min_length=11, max_length=22),
        enabled: str = 'enabled', # enabled, disabled, all
        approved: str = 'all', # approve(d), not_approved, all
        hidden: str = 'not_hidden', # hidden, not_hidden, all
        review: str = 'all', # ready, not_ready, all
        inc_address: bool = False, # Under event and under contact
        # inc_address_location: bool = False,
        inc_contact: bool = False,
        # inc_contact_1: bool = False,
        # inc_contact_2: bool = False,
        # inc_contact_3: bool = False,
        inc_event_abstract_list: bool = False,
        inc_event_badge_list: bool = False,
        inc_event_cfg: bool = False,
        inc_event_device_list: bool = False,
        inc_event_exhibit_list: bool = False,
        inc_event_file_list: bool = False,
        inc_event_location: bool = False,
        inc_event_location_list: bool = False,
        inc_event_person_list: bool = False,
        inc_event_presentation_list: bool = False,
        inc_event_presenter_cat: bool = False,
        inc_event_presenter_list: bool = False,
        inc_event_registration_cfg: bool = False,
        inc_event_registration_list: bool = False,
        inc_event_session_list: bool = False,
        inc_event_track: bool = False,
        inc_event_track_list: bool = False,
        inc_organization: bool = False,
        inc_person: bool = False,
        inc_poc_event_person: bool = False,
        inc_product: bool = False,
        inc_product_list: bool = False,
        # inc_user: bool = False,
        inc_file_count: bool = False, # NOTE: file counts are from separate views
        x_account_id: str = Header(...),
        limit: int = 500, # For now this covers any included objects or object lists
        by_alias: Optional[bool] = True,
        exclude_unset: Optional[bool] = True,
        response: Response = Response,
        ):
    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    if event_id := redis_lookup_id_random(record_id_random=event_id, table_name='event'): pass
    else: return mk_resp(data=None, status_code=404, response=response)

    # NOTE: WARNING NOTE: WARNING NOTE: WARNING NOTE: WARNING NOTE: WARNING NOTE: WARNING NOTE: WARNING
    # time.sleep(2.5) # NOTE: WARNING NOTE: WARNING NOTE: WARNING NOTE: WARNING NOTE: WARNING NOTE: WARNING
    # NOTE: WARNING NOTE: WARNING NOTE: WARNING NOTE: WARNING NOTE: WARNING NOTE: WARNING NOTE: WARNING

    if event_obj := load_event_obj(
            event_id = event_id,
            enabled = enabled,
            approved = approved,
            hidden = hidden,
            review = review,
            inc_file_count = inc_file_count,
            inc_address = inc_address,
            # inc_address_location = inc_address_location,
            inc_contact = inc_contact,
            # inc_event_abstract_list = inc_event_abstract_list,
            inc_event_badge_list = inc_event_badge_list,
            inc_event_cfg = inc_event_cfg,
            inc_event_device_list = inc_event_device_list,
            inc_event_exhibit_list = inc_event_exhibit_list,
            inc_event_file_list = inc_event_file_list,
            inc_event_location = inc_event_location,
            inc_event_location_list = inc_event_location_list,
            # inc_event_person = inc_event_person,
            inc_event_person_list = inc_event_person_list,
            inc_event_presentation_list = inc_event_presentation_list,
            inc_event_presenter_cat = inc_event_presenter_cat,
            inc_event_presenter_list = inc_event_presenter_list,
            inc_event_registration_cfg = inc_event_registration_cfg,
            # inc_event_registration_list = inc_event_registration_list,
            inc_event_session_list = inc_event_session_list,
            # inc_event_track = inc_event_track,
            # inc_event_track_list = inc_event_track_list,
            # inc_order_list = inc_order_list,
            inc_organization = inc_organization,
            inc_person = inc_person,
            inc_poc_event_person = inc_poc_event_person,
            # inc_product = inc_product,
            # inc_product_list = inc_product_list,
            # inc_user = inc_user,
            limit = limit,
            by_alias = by_alias,
            exclude_unset = exclude_unset,
            # model_as_dict = model_as_dict,
            ):
        # event_dict = event_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset)
        pass
    else:
        log.warning('Likely bad request')
        return mk_resp(data=False, status_code=400, response=response) # Bad Request

    return mk_resp(data=event_obj, response=response)
# ### END ### API Event ### get_event_obj() ###


# ### BEGIN ### API Event ### get_account_obj_event_list() ###
# Updated 2021-12-13
@router.get('/account/{account_id}/event/list', response_model=Resp_Body_Base)
async def get_account_obj_event_list(
        account_id: str = Path(min_length=11, max_length=22),
        limit: int = 500,
        enabled: str = 'enabled',
        archived: str = 'not_archived', # archived, not_archived, all
        hidden: str = 'not_hidden', # hidden, not_hidden, all
        conference: bool = False, # Events with badges, sessions, presentations, presenters, registration, etc
        # inc_account_cfg: bool = False,
        inc_address: bool = False, # Under event and under contact
        # inc_address_location: bool = False,
        inc_contact: bool = False,
        # inc_event_abstract_list: bool = False,
        # inc_event_badge_list: bool = False,
        inc_event_cfg: bool = False,
        # inc_event_device_list: bool = False,
        # inc_event_exhibit_list: bool = False,
        inc_event_file_list: bool = False,
        inc_event_location: bool = False, # Currently only specific to an event_session
        inc_event_location_list: bool = False,
        # inc_event_person: bool = False,
        inc_event_person_list: bool = False,
        inc_event_presentation_list: bool = False,
        # inc_event_presenter_cat: bool = False,
        inc_event_presenter_list: bool = False,
        # inc_event_registration_cfg: bool = False,
        # inc_event_registration_list: bool = False,
        inc_event_session_list: bool = False,
        # inc_event_track: bool = False,
        # inc_event_track_list: bool = False,
        # inc_order_list: bool = False,
        inc_organization: bool = False,
        inc_person: bool = False,
        inc_poc_event_person: bool = False,
        inc_product: bool = False,
        inc_product_list: bool = False,
        # inc_user: bool = False,
        x_account_id: str = Header(...),
        by_alias: Optional[bool] = True,
        exclude_unset: Optional[bool] = True,
        response: Response = Response,
        ):
    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    if account_id := redis_lookup_id_random(record_id_random=account_id, table_name='account'): pass
    else: return mk_resp(data=None, status_code=404, response=response)

    # Updated 2021-12-13
    if event_rec_list_result := get_event_rec_list(
            account_id = account_id,
            limit = limit,
            enabled = enabled,
            archived = archived,
            hidden = hidden,
            conference = conference,
            ):
        event_result_list = []
        for event_rec in event_rec_list_result:
            if load_event_result := load_event_obj(
                    event_id = event_rec.get('event_id', None),
                    limit = limit,
                    by_alias = by_alias,
                    exclude_unset = exclude_unset,
                    # model_as_dict = model_as_dict,
                    enabled = enabled,
                    inc_address = inc_address,
                    inc_contact = inc_contact,
                    # inc_event_abstract_list = inc_event_abstract_list,
                    # inc_event_badge_list = inc_event_badge_list,
                    inc_event_cfg = inc_event_cfg,
                    # inc_event_device_list = inc_event_device_list,
                    # inc_event_exhibit_list = inc_event_exhibit_list,
                    inc_event_file_list = inc_event_file_list,
                    inc_event_location = inc_event_location,
                    inc_event_location_list = inc_event_location_list,
                    # inc_event_person = inc_event_person,
                    inc_event_person_list = inc_event_person_list,
                    inc_event_presentation_list = inc_event_presentation_list,
                    # inc_event_presenter_cat = inc_event_presenter_cat,
                    inc_event_presenter_list = inc_event_presenter_list,
                    # inc_event_registration_cfg = inc_event_registration_cfg,
                    # inc_event_registration_list = inc_event_registration_list,
                    inc_event_session_list = inc_event_session_list,
                    # inc_event_track = inc_event_track,
                    # inc_event_track_list = inc_event_track_list,
                    # inc_order_list = inc_order_list,
                    inc_organization = inc_organization,
                    inc_person = inc_person,
                    # inc_product = inc_product,
                    # inc_product_list = inc_product_list,
                    # inc_user = inc_user,
                    ):
                event_result_list.append(load_event_result)
            else:
                event_result_list.append(None)
        response_data = event_result_list
    elif isinstance(event_rec_list_result, list) or event_rec_list_result is None: # Empty list or None
        log.info('No results')
        return mk_resp(data=None, status_code=404, response=response) # Not Found
    else:
        log.warning('Likely bad request')
        return mk_resp(data=False, status_code=400, response=response) # Bad Request

    log.debug(response_data)

    return mk_resp(data=response_data, response=response)
# ### END ### API Event ### get_account_obj_event_list() ###


# ### BEGIN ### API Event ### get_account_obj_event_meeting_list_flat() ###
# Updated 2021-12-13
@router.get('/account/{account_id}/event/meeting_list_flat', response_model=Resp_Body_Base)
async def get_account_obj_event_meeting_list_flat(
        account_id: str = Path(min_length=11, max_length=22),
        limit: int = 500,
        enabled: str = 'enabled',
        archived: str = 'not_archived', # archived, not_archived, all
        hidden: str = 'not_hidden', # hidden, not_hidden, all
        x_account_id: str = Header(...),
        by_alias: Optional[bool] = True,
        exclude_unset: Optional[bool] = True,
        response: Response = Response,
        ):
    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    if account_id := redis_lookup_id_random(record_id_random=account_id, table_name='account'): pass
    else: return mk_resp(data=None, status_code=404, response=response)

    # Updated 2021-12-13
    if event_meeting_rec_list_result := get_event_meeting_rec_list(
            account_id = account_id,
            limit = limit,
            enabled = enabled,
            archived = archived,
            hidden = hidden,
            ):
        event_result_list = []
        for event_rec in event_meeting_rec_list_result:
            try:
                event_obj = Event_Meeting_Flat_Base(**event_rec)
                log.debug(event_obj)
            except ValidationError as e:
                log.error(e.json())
                continue
            event_result_list.append(event_obj)
        response_data = event_result_list
    elif isinstance(event_meeting_rec_list_result, list) or event_meeting_rec_list_result is None: # Empty list or None
        log.info('No results')
        return mk_resp(data=None, status_code=404, response=response) # Not Found
    else:
        log.warning('Likely bad request')
        return mk_resp(data=False, status_code=400, response=response) # Bad Request

    log.debug(response_data)

    return mk_resp(data=response_data, response=response)
# ### END ### API Event ### get_account_obj_event_list() ###


# ### BEGIN ### API Event Methods ### get_person_event_obj_li() ###
# Updated 2021-07-12
@router.get('/person/{person_id}/event/list', response_model=Resp_Body_Base)
async def get_person_event_obj_li(
        person_id: str = Path(min_length=11, max_length=22),
        enabled: str = 'enabled',
        limit: int = 1000,
        conference: bool = False, # If it is a conference then organization, person, and user are queried as participants (not the owner/organizer)
        inc_address: bool = False,
        inc_contact: bool = False,
        inc_event_abstract_list: bool = False,
        inc_event_badge: bool = False,
        inc_event_cfg: bool = False,
        inc_event_exhibit_list: bool = False,
        inc_event_file_list: bool = False,
        inc_event_presentation_list: bool = False,
        inc_event_presenter_list: bool = False,
        inc_event_registration: bool = False,
        inc_event_session_list: bool = False,
        inc_event_track_list: bool = False,
        inc_organization: bool = False,
        inc_person: bool = False,
        x_account_id: str = Header(...),
        by_alias: Optional[bool] = True,
        exclude_unset: Optional[bool] = True,
        response: Response = Response,
        ):
    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    if person_id := redis_lookup_id_random(record_id_random=person_id, table_name='person'): pass
    else: return mk_resp(data=None, status_code=404, response=response)

    # Updated 2021-07-12
    if event_rec_list_result := get_event_rec_list(
            person_id = person_id,
            limit = limit,
            enabled = enabled,
            conference = conference,
            ):
        event_result_list = []
        for event_rec in event_rec_list_result:
            if load_event_result := load_event_obj(
                    event_id = event_rec.get('event_id', None),
                    enabled = enabled,
                    limit = limit,
                    inc_address = inc_address,
                    inc_contact = inc_contact,
                    inc_event_cfg = inc_event_cfg,
                    inc_organization = inc_organization,
                    inc_person = inc_person,
                    by_alias = by_alias,
                    exclude_unset = exclude_unset,
                    # model_as_dict = model_as_dict,
                    ):
                event_result_list.append(load_event_result)
            else:
                event_result_list.append(None)
        response_data = event_result_list
    elif event_rec_list_result is None:
        log.info('No results')
        return mk_resp(data=None, status_code=404, response=response) # Not Found
    else:
        log.warning('Likely bad request')
        return mk_resp(data=False, status_code=400, response=response) # Bad Request

    log.debug(response_data)

    return mk_resp(data=response_data, response=response)
# ### END ### API Event Methods ### get_person_event_obj_li() ###


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

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