from __future__ import annotations
import datetime, hashlib, os, pathlib, shutil, time

from fastapi import File, UploadFile
from typing import Dict, List, Optional, Set, Union
from pydantic import BaseModel, EmailStr, Field, PrivateAttr, ValidationError, validator

from app.db_sql import get_id_random, redis_lookup_id_random, sql_enable_part, sql_insert, sql_limit_offset_part, sql_select, sql_update
from app.lib_general import log, logging

from app.methods.hosted_file_methods import load_hosted_file_obj

from app.models.event_file_models import Event_File_Base


# ### BEGIN ### API Event File Methods ### create_event_file_obj() ###
def create_event_file_obj(event_file_obj_new:Event_File_Base):
    log.setLevel(logging.WARNING) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    # event_file_obj_data = event_file_obj_new.dict(by_alias=False, exclude_defaults=False, exclude_unset=True, exclude={'created_on', 'updated_on'})
    event_file_obj_data = event_file_obj_new.dict(by_alias=False, exclude_defaults=False, exclude_unset=True, exclude={'saved', 'already_exists', 'copy_timer', 'created_on', 'updated_on'})

    if event_file_obj_in_result := sql_insert(data=event_file_obj_data, table_name='event_file', rm_id_random=True, id_random_length=8): pass
    else:
        return False

    log.debug(event_file_obj_in_result)

    event_file_id = event_file_obj_in_result

    log.debug(f'Returning the new event_file_id: {event_file_id}')
    return event_file_id
# ### END ### API Event File Methods ### create_event_file_obj() ###


# ### BEGIN ### API Event File Methods ### load_event_file_obj() ###
def load_event_file_obj(
        event_file_id: int|str,
        model_as_dict: bool = False, # This was defaulted to True 2022-03-07
        by_alias: bool = True,
        exclude_unset: bool = False,
        enabled: str = 'enabled', # enabled, disabled, all
        inc_hosted_file: bool = False,
        ) -> Event_File_Base|dict|bool:
    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    if event_file_id := redis_lookup_id_random(record_id_random=event_file_id, table_name='event_file'): pass
    else: return False

    # NOTE: What table or view should be used here???
    if event_file_rec := sql_select(table_name='v_event_file_simple', record_id=event_file_id):
        log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
        log.debug(event_file_rec)
    else:
        return False

    if event_file_rec.get('for_type') and event_file_rec.get('for_id') and not event_file_rec.get('for_id_random'):
        event_file_rec['for_id_random'] = get_id_random(event_file_rec.get('for_id'), table_name=event_file_rec.get('for_type'))

    hosted_file_id = event_file_rec.get('hosted_file_id', None)

    try:
        event_file_obj = Event_File_Base(**event_file_rec)
    except ValidationError as e:
        log.error(e.json())
        return False
    log.debug(event_file_obj)

    if inc_hosted_file and hosted_file_id:
        log.info('Need to include hosted file...')
        if hosted_file_obj := load_hosted_file_obj(
                hosted_file_id = hosted_file_id,
                enabled = enabled,
                ):
            event_file_obj.hosted_file = hosted_file_obj
            # event_file_obj.hosted_file = hosted_file_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset)
        else:
            event_file_obj.hosted_file = {}
    else:
        event_file_obj.hosted_file = None

    log.debug(event_file_obj)

    if model_as_dict:
        return event_file_obj.dict(by_alias=by_alias, exclude_unset=exclude_unset) # pylint: disable=no-member
    else:
        return event_file_obj
# ### END ### API Event File Methods ### load_event_file_obj() ###


# ### BEGIN ### API Event File Methods ### get_event_file_rec_list() ###
# Updated 2021-09-10
def get_event_file_rec_list(
        for_type: str, # NOTE: This is not for_obj_type because the field name is actually for_type
        for_id: int|str, # NOTE: This is not for_obj_id because the field name is actually for_id
        file_purpose_id: int = None, # NOTE: Not prefixed with lu_
        file_purpose: str = None,
        priority: bool = None,
        group: str = None,
        # event_id: str = None,
        # event_person_id: str = None,
        # event_presentation_id: str = None,
        # event_presenter_id: str = None,
        # event_session_id: str = None,
        enabled: str = 'enabled', # enabled, disabled, all
        limit: int = 100,
        ) -> list|bool:
    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    if for_id := redis_lookup_id_random(record_id_random=for_id, table_name=for_type): pass
    else: return False

    data = {}
    data['for_type'] = for_type
    data['for_id'] = for_id
    data['file_purpose_id'] = file_purpose_id
    data['file_purpose'] = file_purpose
    data['priority'] = priority
    # data['sort'] = sort
    data['group'] = group # Same or similar as file purpose?

    sql_for_type_id = f'`event_file`.for_type = :for_type AND `event_file`.for_id = :for_id'

    if file_purpose_id:
        sql_file_purpose_id = f'AND `event_file`.lu_file_purpose_id = :file_purpose_id'
    else:
        sql_file_purpose_id = ''

    if file_purpose:
        sql_file_purpose = f'AND `event_file`.file_purpose = :file_purpose'
    else:
        sql_file_purpose = ''

    if priority:
        sql_priority = f'AND `event_file`.priority = :priority'
    else:
        sql_priority = ''

    if group:
        sql_group = f'AND `event_file`.group = :group'
    else:
        sql_group = ''

    if enabled in ['enabled', 'disabled', 'all']:
        if enabled == 'enabled':
            data['enable'] = True
            sql_enabled = f'AND `event_file`.enable = :enable'
        elif enabled == 'disabled':
            data['enable'] = False
            sql_enabled = f'AND `event_file`.enable = :enable'
        elif enabled == 'all':
            sql_enabled = ''

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

    sql = f"""
        SELECT `event_file`.id AS 'event_file_id', `event_file`.id_random AS 'event_file_id_random'
        FROM `event_file` AS `event_file`
        WHERE
            {sql_for_type_id}
            {sql_file_purpose_id}
            {sql_file_purpose}
            {sql_priority}
            {sql_group}
            {sql_enabled}
        ORDER BY `event_file`.created_on DESC, `event_file`.updated_on DESC
        {sql_limit};
        """
    log.debug(sql)

    if event_file_rec_li_result := sql_select(data=data, sql=sql, as_list=True):

        event_file_rec_li = event_file_rec_li_result
    else:
        event_file_rec_li = []
    log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(event_file_rec_li_result)
    log.debug(type(event_file_rec_li))
    log.debug(len(event_file_rec_li))

    return event_file_rec_li
# ### END ### API Event File Methods ### get_event_file_rec_list() ###




# ### BEGIN ### API Event File Methods ### load_event_file_obj_list() ###
def load_event_file_obj_list(
        event_id: int|str|None = None,
        event_session_id: int|str|None = None,
        limit: int = 1000,
        model_as_dict: bool = False,
        enabled: str = 'enabled', # enabled, disabled, all
        inc_hosted_file: bool = False,
        ) -> list|bool:
    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    data: dict = {}
    if event_id:
        if event_id := redis_lookup_id_random(record_id_random=event_id, table_name='event'): pass
        else: return False
        data['for_type'] = 'event'
        data['for_id'] = event_id
        sql_obj_type_id = f'`tbl`.for_type = :for_type AND `tbl`.for_id = :for_id'
    elif event_session_id:
        if event_session_id := redis_lookup_id_random(record_id_random=event_session_id, table_name='event_session'): pass
        else: return False
        data['for_type'] = 'event_session'
        data['for_id'] = event_session_id
        sql_obj_type_id = f'`tbl`.for_type = :for_type AND `tbl`.for_id = :for_id'

    if enabled in ['enabled', 'disabled', 'all']:
        if enabled == 'enabled':
            data['enable'] = True
            sql_enabled = f'AND `tbl`.enable = :enable'
        elif enabled == 'disabled':
            data['enable'] = False
            sql_enabled = f'AND `tbl`.enable = :enable'
        elif enabled == 'all':
            sql_enabled = ''
    # else: tbl_obj['account'] = None

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

    sql = f"""
        SELECT `tbl`.id AS 'event_file_id', `tbl`.id_random AS 'event_file_id_random'
        FROM `event_file` AS `tbl`
        WHERE
            {sql_obj_type_id}
            {sql_enabled}
        ORDER BY `tbl`.created_on DESC, `tbl`.updated_on DESC
        {sql_limit};
        """

    if event_file_rec_li_result := sql_select(data=data, sql=sql, as_list=True):
        log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
        log.debug(event_file_rec_li_result)
        event_file_result_li = []
        for event_file_rec in event_file_rec_li_result:
            event_file_id = event_file_rec.get('event_file_id', None)
            if event_file_result := load_event_file_obj(
                event_file_id = event_file_id,
                model_as_dict = True, # NOTE: This is overriding the model_as_dict param!
                enabled = enabled,
                inc_hosted_file = inc_hosted_file,
                ):
                log.debug(event_file_result)
                event_file_result_li.append(event_file_result)
            else:
                log.debug(event_file_result)
                event_file_result_li.append(None)
        # log.debug(event_file_result_li)
    else:
        log.setLevel(logging.DEBUG) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
        log.debug(event_file_rec_li_result)
        event_file_result_li = []

    return event_file_result_li
# ### END ### API Event Methods ### load_event_file_obj_list() ###