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.membership_cfg_models import Membership_Cfg_Base
from app.models.membership_member_profile_models import Membership_Member_Profile_Base
from app.models.membership_type_models import Membership_Type_Base
# from app.models.person_models import Person_Base
from app.models.product_models import Product_Base
# from app.models.user_models import User_Base


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

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

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

    membership_type_id_random: Optional[str]
    membership_type_id: Optional[int] # NOTE: This is not optional

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

    product_id_random: Optional[str]
    product_id: Optional[int] # The product they purchased to get this membership

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

    level_number: Optional[int] = Field(0, ge=0, lt=150)
    level_name: Optional[str]

    # type_id: Optional[int]
    # type_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

    # Including other related objects
    membership_type: Optional[Membership_Type_Base] # The membership option they currently have
    cfg: Optional[Membership_Cfg_Base]
    membership_group_list: Optional[list] # Membership_Group_Base() The membership groups they are a part of
    membership_member_profile: Optional[Membership_Member_Profile_Base]
    person: Optional[dict] # should be Person_Base() but causes an import loop
    product: Optional[Product_Base] # The product used to become a member?
    user: Optional[dict] # should be User_Base() but causes an import loop

    extended_member_profile: Optional[dict] = {}

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

    #@validator('membership_member_id_random', always=True)
    def membership_member_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_member_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_member')
        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('membership_type_id', always=True)
    def membership_type_id_lookup(cls, v, values, **kwargs):
        log.setLevel(logging.WARNING)
        log.debug(locals())

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

    #     if values['product_id_random']:
    #         return redis_lookup_id_random(record_id_random=values['product_id_random'], table_name='product')
    #     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()