from __future__ import annotations
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 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.event_models import Event_Base
# from app.models.event_abstract_models import Event_Abstract_Base
from app.models.event_person_models import Event_Person_Base
# from app.models.event_presentation_models import Event_Presentation_Base
# from app.models.event_session_models import Event_Session_Base
# from app.models.person_models import Person_Base
# from app.models.user_models import User_Base


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

    id_random: Optional[str] = Field(
        **base_fields['event_presenter_id_random'],
        alias = 'event_presenter_id_random',
        default_factory = lambda:secrets.token_urlsafe(default_num_bytes),
    )
    id: Optional[int] = Field(
        alias = 'event_presenter_id'
    )
    account_id_random: Optional[str]
    account_id: Optional[int]

    event_id_random: Optional[str]
    event_id: Optional[int]

    # event_abstract_id_random: Optional[str]
    # event_abstract_id: Optional[int]

    #event_location_id_random: Optional[str]
    #event_location_id: Optional[int]

    event_person_id_random: Optional[str]
    event_person_id: Optional[int]

    event_presentation_id_random: Optional[str]
    event_presentation_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]

    # person_id_random: Optional[str]
    # person_id: Optional[int]

    for_type: Optional[str]
    for_id: Optional[int]

    code: Optional[str]

    pronouns: Optional[str] # Preferred pronouns
    informal_name: Optional[str] # Informal or nick name they commonly go by

    title_names: Optional[str] # Title for generation, official position, or professional or academic qualification, other honorific, or other name prefix
    prefix: Optional[str] # NOTE: Phasing out! Use *title_names* instead.
    given_name: Optional[str]
    middle_name: Optional[str]
    family_name: Optional[str]
    designations: Optional[str] # Temporary or long-term designations related to family, relationships, person differentiation (Junior/Senior), location, social status, professional qualifications, legal status, or other name suffix
    suffix: Optional[str] # NOTE: Phasing out! Use *designations* instead.

    professional_title: Optional[str] # Professional title
    title: Optional[str] # NOTE: Phasing out! Use *professional_title* instead.

    display_name: Optional[str] # Custom what they want for public display

    full_name: Optional[str]

    degree: Optional[str] # NOTE: Phasing out! Use *designations* instead.
    degrees: Optional[str] # NOTE: Phasing out! Use *designations* instead.
    credentials: Optional[str] # NOTE: Phasing out! Use *designations* instead.

    affiliations: Optional[str] # One or more affiliations with organizations, companies, and other groups
    affiliation: Optional[str] # NOTE: Phasing out! Use *affiliations* instead.

    email: Optional[str]
    website_url: Optional[str]

    tagline: Optional[str]
    biography: Optional[str]

    picture_path: Optional[str]
    picture_bg_color: Optional[str]

    role: Optional[str]

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

    hide: Optional[bool]
    public: Optional[bool]
    public_hide: Optional[bool]
    hide_event_launcher: Optional[bool]

    priority: Optional[bool]
    sort: Optional[int]
    group: Optional[str]

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

    # Including other related objects
    # event: Optional[Event_Base]
    # event_abstract: Optional[Event_Abstract_Base]
    event_abstract: Optional[dict]
    event_abstract_list: Optional[list] # Optional[Event_Abstract_Base] Is more than one abstract allowed per presenter?
    # event_device_list: Optional[list] # Optional[Event_Device_Base]
    event_file_list: Optional[list] # Optional[Event_File_Base]
    # event_location: Optional[Event_Location_Base]
    event_person: Optional[Event_Person_Base]
    if __name__ == '__main__':
        from app.models.event_presentation_models import Event_Presentation_Base
        event_presentation: Optional[Event_Presentation_Base]
    else:
        event_presentation: Optional[dict]
    # event_presentation: Optional[dict]
    # event_session: Optional[Event_Session_Base]
    event_session: Optional[dict]
    # event_track: Optional[Event_Track_Base]
    # person: Optional[Person_Base] # This is under event_person
    # user: Optional[User_Base] # This is under event_person

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

    #@validator('event_presenter_id_random', always=True)
    def event_presenter_id_random_copy(cls, v, values, **kwargs):
        log.setLevel(logging.WARNING)
        log.debug(locals())

        if values['id_random']:
            return values['id_random']
        return None

    @validator('id', always=True)
    def event_presenter_id_lookup(cls, v, values, **kwargs):
        log.setLevel(logging.WARNING)
        log.debug(locals())

        if values['id_random']:
            log.debug(values['id_random'])
            return redis_lookup_id_random(record_id_random=values['id_random'], table_name='event_presenter')
        return None

    @validator('account_id', always=True)
    def account_id_lookup(cls, v, values, **kwargs):
        log.setLevel(logging.WARNING)
        log.debug(locals())

        if values['account_id_random']:
            return redis_lookup_id_random(record_id_random=values['account_id_random'], table_name='account')
        return None

    @validator('event_id', always=True)
    def event_id_lookup(cls, v, values, **kwargs):
        log.setLevel(logging.WARNING)
        log.debug(locals())

        if values['event_id_random']:
            return redis_lookup_id_random(record_id_random=values['event_id_random'], table_name='event')
        return None

    @validator('event_person_id', always=True)
    def event_person_id_lookup(cls, v, values, **kwargs):
        log.setLevel(logging.WARNING)
        log.debug(locals())

        if values['event_person_id_random']:
            return redis_lookup_id_random(record_id_random=values['event_person_id_random'], table_name='event_person')
        return None

    @validator('event_presentation_id', always=True)
    def event_presentation_id_lookup(cls, v, values, **kwargs):
        log.setLevel(logging.WARNING)
        log.debug(locals())

        if values['event_presentation_id_random']:
            return redis_lookup_id_random(record_id_random=values['event_presentation_id_random'], table_name='event_presentation')
        return None

    @validator('event_session_id', always=True)
    def event_session_id_lookup(cls, v, values, **kwargs):
        log.setLevel(logging.WARNING)
        log.debug(locals())

        if values['event_session_id_random']:
            return redis_lookup_id_random(record_id_random=values['event_session_id_random'], table_name='event_session')
        return None

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