import datetime, hashlib, logging, os, pytz, redis, secrets

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

from app.db_sql import get_id_random, redis_lookup_id_random
from app.lib_general import log, logging

from app.models.common_field_schema import base_fields, default_num_bytes
from app.models.hosted_file_models import Hosted_File_Base


class Event_File_Base(BaseModel):
    log.setLevel(logging.INFO) # DEBUG, INFO, WARNING, ERROR, EXCEPTION, CRITICAL
    log.debug(locals())

    id_random: Optional[str] = Field(
        **base_fields['event_file_id_random'],
        alias = 'event_file_id_random',
        default_factory = lambda:secrets.token_urlsafe(default_num_bytes),
    )
    id: Optional[int] = Field(
        alias = 'event_file_id'
    )

    hosted_file_id_random: Optional[str]
    hosted_file_id: Optional[int]

    # NOTE: Handeling this outside of the Pydantic model and model validation. See below as well. -STI 2021-09-10
    for_type: Optional[str]
    for_id: Optional[int] # NOTE: This is reversed with for_id_random
    for_id_random: Optional[str] # NOTE: This is reversed with for_id
    # for_id_random: Optional[str] = None # Need to override value from common_field_schema.py
    # for_id: Optional[int]

    event_id_random: Optional[str]
    event_id: Optional[int]
    event_exhibit_id_random: Optional[str]
    event_exhibit_id: Optional[int]
    event_location_id_random: Optional[str]
    event_location_id: Optional[int]
    event_presentation_id_random: Optional[str]
    event_presentation_id: Optional[int]
    event_presenter_id_random: Optional[str]
    event_presenter_id: Optional[int]
    event_session_id_random: Optional[str]
    event_session_id: Optional[int]
    event_track_id_random: Optional[str]
    event_track_id: Optional[int]

    filename: Optional[str]
    extension: Optional[str]
    title: Optional[str]
    description: Optional[str]

    lu_file_purpose_id: Optional[int]
    file_purpose: Optional[str]

    #### NOTE ***** NOTE
    internal_os: Optional[str]
    public_use: Optional[bool] = False
    public: Optional[bool]
    approve: Optional[bool]
    #### internal_os needs to be set
    #### Are other important fields missing????
    #### NOTE ^^^^^ NOTE

    enable: Optional[bool]
    enable_from: Optional[datetime.datetime] = None
    enable_to: Optional[datetime.datetime] = None

    hide: Optional[bool]
    priority: Optional[bool]
    sort: Optional[int]
    group: Optional[str] # Same or similar as file_purpose?

    # notes: Optional[str]
    created_on: Optional[datetime.datetime] = None
    updated_on: Optional[datetime.datetime] = None

    # Including convenience data
    # This is only for convenience. Probably going to keep unless it causes a problem.
    hosted_file_hash_sha256: Optional[str] = Field(
        alias = 'hash_sha256'
    )
    hosted_file_subdirectory_path: Optional[str] = Field(  # NOTE: This will frequently only contain numbers, but it still needs to be a string
        alias = 'subdirectory_path'
    )
    hosted_file_content_type: Optional[str] = Field(
        alias = 'content_type'
    )
    hosted_file_size: Optional[str] = Field(
        alias = 'file_size'
    )

    # Including other related objects
    hosted_file: Optional[Union[Hosted_File_Base, None]]

    _processed_at: datetime.datetime = PrivateAttr(default_factory=datetime.datetime.now)

    #@validator('event_file_id_random', always=True)
    def event_file_id_random_copy(cls, v, values, **kwargs):
        if values['id_random']:
            return values['id_random']
        return None

    @validator('id', always=True)
    def event_file_id_lookup(cls, v, values, **kwargs):
        if isinstance(v, int) and v > 0: return v
        elif id_random := values.get('id_random'):
            return redis_lookup_id_random(record_id_random=id_random, table_name='event_file')
        return None

    @validator('hosted_file_id', always=True)
    def hosted_file_id_lookup(cls, v, values, **kwargs):
        if isinstance(v, int) and v > 0: return v
        elif id_random := values.get('hosted_file_id_random'):
            return redis_lookup_id_random(record_id_random=id_random, table_name='hosted_file')
        return None

    @validator('event_id', always=True)
    def event_id_lookup(cls, v, values, **kwargs):
        if isinstance(v, int) and v > 0: return v
        elif id_random := values.get('event_id_random'):
            return redis_lookup_id_random(record_id_random=id_random, table_name='event')
        return None

    @validator('event_exhibit_id', always=True)
    def event_exhibit_id_lookup(cls, v, values, **kwargs):
        if isinstance(v, int) and v > 0: return v
        elif id_random := values.get('event_exhibit_id_random'):
            return redis_lookup_id_random(record_id_random=id_random, table_name='event_exhibit')
        return None

    @validator('event_location_id', always=True)
    def event_location_id_lookup(cls, v, values, **kwargs):
        if isinstance(v, int) and v > 0: return v
        elif id_random := values.get('event_location_id_random'):
            return redis_lookup_id_random(record_id_random=id_random, table_name='event_location')
        return None

    @validator('event_presentation_id', always=True)
    def event_presentation_id_lookup(cls, v, values, **kwargs):
        if isinstance(v, int) and v > 0: return v
        elif id_random := values.get('event_presentation_id_random'):
            return redis_lookup_id_random(record_id_random=id_random, table_name='event_presentation')
        return None

    @validator('event_presenter_id', always=True)
    def event_presenter_id_lookup(cls, v, values, **kwargs):
        if isinstance(v, int) and v > 0: return v
        elif id_random := values.get('event_presenter_id_random'):
            return redis_lookup_id_random(record_id_random=id_random, table_name='event_presenter')
        return None

    @validator('event_session_id', always=True)
    def event_session_id_lookup(cls, v, values, **kwargs):
        if isinstance(v, int) and v > 0: return v
        elif id_random := values.get('event_session_id_random'):
            return redis_lookup_id_random(record_id_random=id_random, table_name='event_session')
        return None

    @validator('event_track_id', always=True)
    def event_track_id_lookup(cls, v, values, **kwargs):
        if isinstance(v, int) and v > 0: return v
        elif id_random := values.get('event_track_id_random'):
            return redis_lookup_id_random(record_id_random=id_random, table_name='event_track')
        return None

    # NOTE: I kind of give up on this. Handeling this outside of Pydantic and before the data is even attempted to be loaded into the Event_File_Base model. -STI 2021-09-10
    # NOTE: This validator will try to find and "set" the for_id_random value. However, The value is not really "set" in Pydantic. To get this value, exclude_unset=True when returning a dict from the model.
    # @validator('for_id_random', always=True)
    # def for_id_random_lookup(cls, v, values, **kwargs):
    #     log.setLevel(logging.WARNING)
    #     log.debug(locals())

    #     if values.get('for_id') and values['for_type']:
    #         return get_id_random(record_id=values['for_id'], table_name=values['for_type'])
    #     return None

    # @validator('for_id', always=True)
    # def for_id_lookup(cls, v, values, **kwargs):
    #     log.setLevel(logging.DEBUG)
    #     log.debug(locals())

    #     if values.get('for_id_random', None) and values['for_type']:
    #         return redis_lookup_id_random(record_id_random=values['for_id_random'], table_name=values['for_type'])
    #     # return None
    #     else: return v

    class Config:
        underscore_attrs_are_private = True
        allow_population_by_field_name = True
        fields = base_fields