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.address_models import Address_Base
from app.models.contact_models import Contact_Base
from app.models.event_cfg_models import Event_Cfg_Base
from app.models.event_person_models import Event_Person_Base
from app.models.person_models import Person_Base
from app.models.user_models import User_Base


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

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

    code: Optional[str] = Field(
        alias = 'event_code'
    )

    account_id_random: Optional[str]
    account_id: Optional[int]

    poc_event_person_id_random: Optional[str]
    poc_event_person_id: Optional[int]

    poc_person_id_random: Optional[str]
    poc_person_id: Optional[int]

    user_id_random: Optional[str]
    user_id: Optional[int]

    lu_event_type_id: Optional[int]
    #lu_event_type: Optional[str] # Needs to be reviewed

    conference: Optional[bool] # Also in Event_Cfg_Base model

    # type_name: Optional[str] = Field(
    #     alias = 'type'
    # )
    type: Optional[str]

    name: Optional[str]
    summary: Optional[str]
    description: Optional[str]
    format: Optional[str]

    lu_time_zone_id: Optional[int]
    timezone: Optional[str]
    start_datetime: Optional[datetime.datetime] = None
    end_datetime: Optional[datetime.datetime] = None

    recurring: Optional[bool]
    recurring_pattern: Optional[str]
    recurring_start_time: Optional[datetime.time]
    recurring_end_time: Optional[datetime.time]
    recurring_text: Optional[str]

    weekday_sunday: Optional[bool]
    weekday_monday: Optional[bool]
    weekday_tuesday: Optional[bool]
    weekday_wednesday: Optional[bool]
    weekday_thursday: Optional[bool]
    weekday_friday: Optional[bool]
    weekday_saturday: Optional[bool]

    address_location_id_random: Optional[str]
    address_location_id: Optional[int]
    location_text: Optional[str]

    online_start: Optional[datetime.datetime] = None
    online_end: Optional[datetime.datetime] = None

    reg_deadline_1: Optional[datetime.datetime] = None
    reg_deadline_2: Optional[datetime.datetime] = None
    reg_deadline_3: Optional[datetime.datetime] = None
    reg_deadline_4: Optional[datetime.datetime] = None

    max_registrants: Optional[int]

    private: Optional[bool] # invite only
    physical: Optional[bool] # physical in person event
    virtual: Optional[bool] # virtual remote access event

    contact_1_id_random: Optional[str]
    contact_1_id: Optional[int]
    contact_2_id_random: Optional[str]
    contact_2_id: Optional[int]
    contact_3_id_random: Optional[str]
    contact_3_id: Optional[int]

    attend_url: Optional[str]
    attend_url_passcode: Optional[str]
    attend_phone: Optional[str]
    attend_phone_passcode: Optional[str]
    attend_text: Optional[str]

    # NOT FINISHED YET

    # access_key: Optional[str] # Maybe use in the future?

    enable: Optional[bool] # Also in Event_Cfg_Base model
    enable_from: Optional[datetime.datetime] = None
    enable_to: Optional[datetime.datetime] = None

    archive: Optional[bool] # Also in Event_Cfg_Base model
    archive_on: Optional[datetime.datetime] # Also in Event_Cfg_Base model

    hide: Optional[bool] # Also in Event_Cfg_Base model
    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 JSON data
    event_session_proposal_questions: Optional[Json] # list of dicts (custom for client) for event_session proposals

    # Including other related objects
    address_location: Optional[Address_Base]
    contact_1: Optional[Contact_Base]
    contact_2: Optional[Contact_Base]
    contact_3: Optional[Contact_Base]
    event_abstract_list: Optional[list] # Optional[Event_Abstract_Base]
    event_cfg: Optional[Event_Cfg_Base]
    event_device_list: Optional[list] # Optional[Event_Device_Base]
    event_file_list: Optional[list] # Optional[Event_File_Base]
    event_location_list: Optional[list] # Optional[Event_Location_Base]
    event_person_list: Optional[list]
    event_presentation_list: Optional[list] # Optional[Event_Presentation_Base]
    event_presenter_list: Optional[list] # Optional[Event_Presenter_Base]
    event_session_list: Optional[list] # Optional[Event_Session_Base]
    event_track_list: Optional[list] # Optional[Event_Track_Base]
    # poc_event_person: Optional[Event_Person_Base]
    poc_person: Optional[Person_Base]
    user: Optional[User_Base]

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

    #@validator('event_id_random', always=True)
    def event_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_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')
        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('poc_event_person_id', always=True)
    def poc_event_person_id_lookup(cls, v, values, **kwargs):
        log.setLevel(logging.WARNING)
        log.debug(locals())

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

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

        if values['poc_person_id_random']:
            return redis_lookup_id_random(record_id_random=values['poc_person_id_random'], table_name='person')
        return None

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

        if values['user_id_random']:
            return redis_lookup_id_random(record_id_random=values['user_id_random'], table_name='user')
        return None

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

        if values['address_location_id_random']:
            return redis_lookup_id_random(record_id_random=values['address_location_id_random'], table_name='address')
        return None

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

        if values['contact_1_id_random']:
            return redis_lookup_id_random(record_id_random=values['contact_1_id_random'], table_name='contact')
        return None

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

        if values['contact_2_id_random']:
            return redis_lookup_id_random(record_id_random=values['contact_2_id_random'], table_name='contact')
        return None

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

        if values['contact_3_id_random']:
            return redis_lookup_id_random(record_id_random=values['contact_3_id_random'], table_name='contact')
        return None

    @validator('created_on', always=True)
    def created_on_utc(cls, v, values, **kwargs):
        if isinstance(v, datetime.datetime):
            return v.astimezone(pytz.UTC).isoformat()
        else: return v

    @validator('updated_on', always=True)
    def updated_on_utc(cls, v, values, **kwargs):
        if isinstance(v, datetime.datetime):
            return v.astimezone(pytz.UTC).isoformat()
        else: return v

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

# Event_Base.update_forward_refs() # NOTE: This is needed since Event_Cfg_Base is below Event_Base.