# +----------------------------------------------------------------------
# | ChatWork智能聊天办公系统
# +----------------------------------------------------------------------
# | 软件声明: 本系统并非自由软件,未经授权任何形式的商业使用均属非法。
# | 版权保护: 任何企业和个人不允许对程序代码以任何形式任何目的复制/分发。
# | 授权要求: 如有商业使用需求,请务必先与版权所有者取得联系并获得正式授权。
# +----------------------------------------------------------------------
# | Author: ChatWork Team <2474369941@qq.com>
# +----------------------------------------------------------------------
import os
import time
import inspect
import importlib
import operator
from functools import reduce
from typing import Union, TypeVar, Type, Any, List, Tuple
from pydantic import TypeAdapter
from tortoise.models import Model
from tortoise.queryset import Q
from hypertext import PagingResult

__all__ = ["DbModel"]


class DbModel(Model):
 """ Model base class """
 MODEL = TypeVar("MODEL", bound="Model")

 DB_CONFIGS = {}

 class Meta:
 abstract = True

 @classmethod
 async def paginate(
 cls, model: Type[MODEL],
 page_no: int = 1,
 page_size: int = 15,
 schema: Any = None,
 fields: List = None,
 auto_timestamp: bool = True,
 datetime_field: List = None,
 datetime_format: str = "%Y-%m-%d %H:%M:%S",
 ):
 fields = [] if not fields else fields
 _count = await model.count()
 _lists = await model.limit(page_size).offset((page_no - 1) * page_size).values(*fields)

 for item in _lists:
 if auto_timestamp:
 tf = datetime_field if datetime_field else ["create_time", "update_time", "delete_time"]
 for s in tf:
 if item.get(s) is not None and not item.get(s):
 item[s] = ""
 elif item.get(s):
 time_array = time.localtime(item.get(s))
 item[s] = time.strftime(datetime_format, time_array)

 if schema:
 _lists = [TypeAdapter(schema).validate_python(item) for item in _lists]

 return PagingResult.create(_lists, _count, page_no, page_size)

 @classmethod
 def without_field(cls, fields: Union[str, List, Tuple]):
 _fields = []
 _values = fields.split(",") if isinstance(fields, str) else fields
 for field in cls._meta.fields:
 if field not in _values:
 _fields.append(field.strip())
 return _fields

 @classmethod
 def build_search(cls, search: dict, params: dict):
 factor = {
 "=": "",
 ">": "gt",
 "<": "lt",
 ">=": "__gte",
 "<=": "__lte",
 "<>": "__not",
 "%like%": "__contains",
 "%ilike%": "__icontains",
 "like%": "__startswith",
 "ilike%": "__istartswith",
 "%like": "__endswith",
 "%ilike": "__iendswith",
 "isnull": "__isnull",
 "not_isnull": "__not_isnull",
 "iexact": "__iexact",
 "search": "__search",
 "year": "__year",
 "month": "__month",
 "day": "__day",
 }

 where = []
 for whereType, whereFields in search.items():
 for whereField in whereFields:
 w = whereField.split("@")
 key = w[0] if len(w) >= 2 else whereField
 field = w[1] if len(w) >= 2 else whereField

 if factor.get(whereType) or whereType == "=":
 if params.get(key, None) is None or params.get(key, None) == "":
 continue
 suffix = factor.get(whereType)
 fields = field.split("|")
 if len(fields) > 1:
 or_where = []
 for f in fields:
 or_where.append(Q(**{(f.strip())+suffix: params.get(key)}))
 where.append(reduce(operator.or_, or_where))
 else:
 where.append(Q(**{field+suffix: params.get(key)}))

 elif whereType == "datetime":
 d = key.split("|")
 s_: str = d[0] if len(d) >= 2 else key
 e_: str = d[1] if len(d) >= 2 else None
 # StartTime
 if s_ and params.get(s_):
 value = params.get(s_)
 if not is_number(value):
 formats = "%Y-%m-%d %H:%M:%S" if len(value.split(" ")) >= 2 else "%Y-%m-%d"
 time_array = time.strptime(value, formats)
 value = int(time.mktime(time_array))
 where.append(Q(**{field + "__gte": value}))
 # EndTime
 if e_ and params.get(e_):
 value = params.get(e_)
 if not is_number(value):
 formats = "%Y-%m-%d %H:%M:%S" if len(value.split(" ")) >= 2 else "%Y-%m-%d"
 time_array = time.strptime(value, formats)
 value = int(time.mktime(time_array))
 where.append(Q(**{field + "__lte": value}))

 return where

 @classmethod
 def table_prefix(cls, table: str = "", engine: str = None):
 if not cls.DB_CONFIGS:
 cls.DB_CONFIGS = loading_db_configs()
 if not cls.DB_CONFIGS or not cls.DB_CONFIGS.get("connections") or not cls.DB_CONFIGS.get("apps"):
 return table

 apps = cls.DB_CONFIGS.get("apps", {})
 if engine is None:
 if not cls.__module__.startswith("kernels.model"):
 for key in apps.keys():
 if cls.__module__.startswith(apps[key].get("models")):
 engine = key
 break
 if engine is None:
 caller_file_path = inspect.stack()[1].filename
 caller_pack_path = caller_file_path.replace(os.sep + caller_file_path.split(os.sep)[-1], "")
 system_root_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + os.sep
 module_apps_path = caller_pack_path.replace(system_root_path, "").replace(os.sep, ".")
 engine = next((key for key in apps.keys() if apps[key].get("models") == module_apps_path), None)

 conn = cls.DB_CONFIGS.get("connections", {}).get(engine, {})
 return conn.get("prefix", "") + table


def is_number(s: any) -> bool:
 try:
 float(s)
 return True
 except ValueError:
 return False


def loading_db_configs():
 """ Load Db configuration """
 configs = {}
 try:
 package = importlib.import_module("config")
 clz = getattr(package, "GlobalSetting", None)
 if not clz:
 return configs

 obj = clz().dict()
 db_config = obj.get("DATABASES", {})

 return db_config
 except ModuleNotFoundError:
 return configs