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 ..db_sql import redis_lookup_id_random
from ..lib_general import *

from .common_field_schema import base_fields, default_num_bytes
from .address_models import Address_Base
from .contact_models import Contact_Base
from .organization_models import Organization_Base
from .person_models import Person_Base
from .user_models import User_Base


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

    account_name: Optional[str]

    cycle_type: Optional[str]
    membership_length: Optional[int] = Field(0, ge=0, lt=150)
    prorate: Optional[bool] = False
    calendar_year_start_buffer_days: Optional[int] = Field(0, ge=0, lt=150)
    calendar_year_start_buffer_on: Optional[datetime.datetime] = None
    calendar_year_start_on: Optional[datetime.datetime] = None
    calendar_year_end_on: Optional[datetime.datetime] = None
    calendar_year_end_buffer_days: Optional[int] = Field(0, ge=0, lt=150)
    calendar_year_end_buffer_on: Optional[datetime.datetime] = None
    enable_privacy_view: Optional[bool] = False

    renew_warning_hours: Optional[int]

    accept_message: Optional[str]
    reject_message: Optional[str]
    renew_message: Optional[str]

    #extended_membership_profile: Optional[str] # list of dicts outlining extended (custom) membership profile fields for client
    extended_membership_profile: Optional[Json] = '[]' # list of dicts outlining extended (custom) membership profile fields for client

    default_no_reply_email: Optional[str]
    default_no_reply_name: Optional[str]
    confirm_email: Optional[str]
    confirm_name: Optional[str]

Membership_Cfg_Base.update_forward_refs()


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

    # if TYPE_CHECKING:
    #     from .supporting_core_models import Address_Base, Contact_Base, Organization_Base, User_Base
    #     from .person_model import Person_Base

    # from .address_model import Address_Base
    # from .contact_model import Contact_Base
    # from .organization_model import Organization_Base
    # from .person_model import Person_Base
    # from .user_model import User_Base

    id_random: Optional[str] = Field(
        **base_fields['membership_profile_id_random'],
        alias='membership_profile_id_random',
        default_factory=lambda:secrets.token_urlsafe(default_num_bytes),
    )
    id: Optional[int] = Field(
        #alias='membership_profile_id'
    )
    membership_id_random: Optional[str]
    membership_id: Optional[int]
    person_id_random: Optional[str]
    person_id: Optional[int]
    user_id_random: Optional[str]
    user_id: Optional[int]
    organization_id_random: Optional[str]
    organization_id: Optional[int]
    contact_id_random: Optional[str]
    contact_id: Optional[int]
    address_id_random: Optional[str]
    address_id: Optional[int]

    display_name: Optional[str]
    email: Optional[str]

    email_allowed: Optional[bool]
    email_newsletter: Optional[bool]
    mail_newsletter: Optional[bool]
    show_online: Optional[bool]
    show_printed: Optional[bool]

    biography: Optional[str]

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

    address: 'Optional[Address_Base]' = Address_Base()
    contact: 'Optional[Contact_Base]' = Contact_Base()
    organization: 'Optional[Organization_Base]' = Organization_Base()
    person: 'Optional[Person_Base]' = Person_Base()
    user: 'Optional[User_Base]' = User_Base()

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

    #@validator('membership_profile_id_random', always=True)
    def membership_profile_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 membership_profile_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='membership_profile')
        return None

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

        if values['membership_id_random']:
            return redis_lookup_id_random(record_id_random=values['membership_id_random'], table_name='membership')
        return None

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

        if values['person_id_random']:
            return redis_lookup_id_random(record_id_random=values['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

    class Config:
        underscore_attrs_are_private = True
        fields = base_fields

Membership_Profile_Base.update_forward_refs()


class Membership_Base(BaseModel):
    log.setLevel(logging.WARNING)
    log.debug(locals())

    #from .supporting_core_models import User_Base
    # from .account_model import Account_Base
    # from .person_model import Person_Base
    # from .user_model import User_Base

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

    account_id_random: Optional[str]
    account_id: Optional[int] # NOTE: This is not really optional
    person_id_random: Optional[str]
    person_id: Optional[int]
    user_id_random: Optional[str]
    user_id: Optional[int]
    level_number: Optional[int] = Field(0, ge=0, lt=150)
    level_name: Optional[str]
    product_id: Optional[int]
    type_id: Optional[int]
    type_name: Optional[str]
    category_id: Optional[int]
    category_name: Optional[str]
    division_id: Optional[int]
    division_name: Optional[str]
    status_id: Optional[int]
    status_name: Optional[str]

    application_start_on: Optional[datetime.datetime] = None
    approved_on: Optional[datetime.datetime] = None
    first_start_on: Optional[datetime.datetime] = None
    start_buffer_on: Optional[datetime.datetime] = None
    start_on: Optional[datetime.datetime] = None
    end_on: Optional[datetime.datetime] = None
    end_buffer_on: Optional[datetime.datetime] = None

    flag: Optional[bool]
    flag_message: Optional[str]

    notes: Optional[str]

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

    #account: Optional[Account_Base] = Account_Base()
    profile: 'Optional[Membership_Profile_Base]' = Membership_Profile_Base()
    person: 'Optional[Person_Base]' = Person_Base()
    user: 'Optional[User_Base]' = User_Base()
    cfg: 'Optional[Membership_Cfg_Base]' = Membership_Cfg_Base()

    extended_profile: Optional[dict] = {}

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

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

        if values['id_random']:
            return redis_lookup_id_random(record_id_random=values['id_random'], table_name='membership')
        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('person_id', always=True)
    def person_id_lookup(cls, v, values, **kwargs):
        log.setLevel(logging.WARNING)
        log.debug(locals())

        if values['person_id_random']:
            return redis_lookup_id_random(record_id_random=values['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

    class Config:
        underscore_attrs_are_private = True
        fields = base_fields

# Membership_Base.update_forward_refs()