import os
import uuid
import json
import re
import datetime
import hashlib
import logging
import threading

logger = logging.getLogger(__name__)

import django
from django.conf import settings
from django.http import HttpResponse, JsonResponse

from gvsds.apps.core.models import User, UserAvatar, EphemeralToken, User2FA, UserPending2FA, AccountActivation, UserLoginLog
from gvsds.apps.gerp.models import (
    Tenant, CompanyInfo, Company, Department, Role, UserRole, RoleDept,
    Permission, FileAsset, WorkOrder, Message, Menu,
    UserABAC, DepartmentSMTM, Password, ItemReference, Backpack,
    SimulatedTrigger, CashReceiptsPaymentsLedger, Asset, Liability,
)

GERPUser = User
GERPUser2FA = User2FA
GERPUserPending2FA = UserPending2FA
GERPRole = Role
GERPMenu = Menu
GERPMessage = Message
GERPCompany = Company
GERPDept = Department
GERPPermission = Permission
GERPUserRole = UserRole
GERPWorkOrder = WorkOrder
GERPFileAsset = FileAsset
GERPTenant = Tenant
GERPCompanyInfo = CompanyInfo
GERPCashReceiptsPaymentsLedger = CashReceiptsPaymentsLedger
GERPAsset = Asset
GERPLiability = Liability
GERPBackpack = Backpack
GERPItemReference = ItemReference
GERPWorkgroup = type('GERPWorkgroup', (), {})
from gvsds.model_base import snake_to_pascal


def _pascal_to_snake(name):
    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
from gvsds.template_engine import ProcessTemplate


class _FlaskCompat:
    request = None
    session = None
    g = type('g', (), {})()
    jsonify = staticmethod(lambda *args, **kwargs: kwargs)

    @staticmethod
    def Response(content, mimetype='text/html', status=200, headers=None):
        content_type = mimetype or 'text/html'
        resp = HttpResponse(content, content_type=content_type, status=status)
        if headers:
            for k, v in headers.items():
                resp[k] = v
        return resp


flask = _FlaskCompat()

UserDefaultAvatar = b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\xc0\x00\x00\x00\xc0\x08\x03\x00\x00\x00e\x02\x9c5\x00\x00\x003PLTE\xfa\xfa\xfa\xfa\xfa\xfa\xfa\xfa\xfa\xf0\xf0\xf0\xe0\xe0\xe0\xc8\xc8\xc8\xb8\xb8\xb8\xc0\xc0\xc0\x8f\x8f\x8f\x90\x90\x90\x98\x98\x98\xa0\xa0\xa0\xa8\xa8\xa8\xb0\xb0\xb0\xd0\xd0\xd0\xd8\xd8\xd8\xe8\xe8\xe8\x92\x11\xe9\x17\x00\x00\x00\x02tRNS\xfe\xfd?\xa0\x8f\xaa\x00\x00\x02\x97IDATx\x01\xed\xda\x07\x92\xad:\x0c\x84\xe1y\xc8\xa1G2\xe6\xec\x7f\xb5\xef\xe6\x9c\xa0N3rU\xff+\xe0#\x83\xf5\xb2\xad\xdd\x8b\x00\x02\x08 \x80\x00\x02\x08 \x80\x00\x02\x08 @\x8e\x04\x10@\x00\x01\x04\x10@\x00\x01\x04\x10@\x00\x01\x04\x10@\x00\x01\x04\xb0R[\x04\x00\xc4\xd8kY\x0c`\xc7p|\x97\xefs\x1d\x80U\xc7/\x8af,\x00\x7f\xf3?U-?\xe0\x08\xfc\xa1\x98\xc9\x01\xd6\xf1\x97\xbae\x06X\xe0\xaf\x85\xe5\x05X\x00|\x01\x0f`\x01\xf0\x05<\x80\x05\xc0\x17\xf0\x00\x16\x00_@\x04t\x9c\xa8\xe7\x03L\x9c\xea\xc8\x06\xb0\xc0\xa9\xc2\x92\x01*N\xd6s\x01\x0cgsK\x05h8]O\x05\x080\x0f\x01\x1f0q\xa1#\x11`\xc7\x85F"\x80\xe3Bni\x00\x05\x97*i\x00\x15\x97\xaai\x00;.\xd5\xd2\x00\x06.\x15i\x00\xb1:\x00\x17c\x02\x04\x10@\x171\x1f0\xd2\x00\x1a.\xb5\xebUB/s\x9f2\xc7\x85<\xd1\xf7\xc0\xe0^\x02|\xc0\x81\x0bM*\x80\x7f\x0eE\xaa\xbf\x12\x1d\xa7k\\\x00\xff\x10X*\xc0\xd6\t\xff\xb5\xf4s\x97y#\x9aZ\xe0\xd0\x12\x13\x7f\x91O\xcb\xac$A\x98F\r4\xec\xf1\x87f\xe0\x0f\xc5A\x1c\xb7\xe1\x1f\x04\xef\xb6\xc6\xc8Y\x0b\xf2\xe6\xf3\xa7\x16\xe7\xee\xf8.\x1f\x87-67Z\xea>\x02\x00"Z-\xa6\xc1W\x01R%\x80\x00\x02\x08Pz8\x9e\x94G+7\x03f\xe0\xc9\xc5\xbc\x11`\x03\x84\x86\xdd\x05\xb0\x00\xa5\xb0{\x00\x16\x00_@\x04\x0c\xd0\x1aw\x00&\x88\xcd\x1b\x00\x01b\xc1\x07\x14P+t@\x03\xb5N\x07\x04\xa8\x05\x1d\xe0\xa0\xe6t\x00\xc8\t \x80\x00\xba\x8d\xbe)`\xac\xfe$\xde\xe9\x80\xbe\xfa\xab\xc4\x01j\x07\x1d`\xa0ft\xc06\xf8\xd70\x17PW\xff"3\x10\xb3\xc5?\xea\xdbv\x07\xa0\x80\x96Q\x01\xfcC\xd0\xee\xfa3\xe7\xa0\xf4jT\x00\xffi\xdc\xef\xfb;\x1d \x14\x1b\x13\xc0?\x89\xc2n\x04l\x0f<\xbb\xd7\xc7\xbd+4\x93\xff\x0c\xe6\x01\x08\x82\xd7y\xff"\xdf\xe1xZ^\xdeb\x95\xd2\x82\x7f\xfdR\x01\x9b5<\xa5f\x1b\x0f\xc0_\xac\xf4\x83\xb9N\xcc?\x08\xdd6>\x80G\x18\xc6_\xa9\xe7\x11\xbc\x95$\xb3\x12v\xe5Z\x88n\x99\x86=J;e\xf0^\xf2M\xab<\xeap\xfcC>\xea#\xed\xb8M\xa9\xedO\n\x8fV\x1f\x0bL\xee\x96\xd9\xdb\x18\x11\x9f(\x1e1\xf6\xd6\xe7a\x1ax\x12@\x00\x01\x04\x10@\x00\x01\x04\x10@\x00\x01\x04\x10@\x00\x01\x04\x10@\x00\x01\x04\x10@\x00\x01\x04\x10\xe0\xcd\x13@\x00\x01\x16\xef\xbf\xff\x01\xf0\x16\xb7@\x05\x81\xe7\\\x00\x00\x00\x00IEND\xaeB`\x82'


def _uuid_to_bytes(val):
    if val is None:
        return None
    if isinstance(val, bytes):
        return val
    if isinstance(val, str):
        try:
            return uuid.UUID(val).bytes
        except ValueError:
            return None
    if isinstance(val, uuid.UUID):
        return val.bytes
    return None


def _uuid_to_str(val):
    if val is None:
        return None
    if isinstance(val, str):
        return val
    if isinstance(val, bytes) and len(val) == 16:
        return str(uuid.UUID(bytes=val))
    if isinstance(val, uuid.UUID):
        return str(val)
    return str(val)


class UUIDObj(str):
    def __new__(cls, value):
        if isinstance(value, bytes) and len(value) == 16:
            uuid_str = str(uuid.UUID(bytes=value))
        elif isinstance(value, str):
            uuid_str = str(uuid.UUID(value))
        elif isinstance(value, uuid.UUID):
            uuid_str = str(value)
        else:
            raise ValueError(f"Invalid UUID: {value}")
        return str.__new__(cls, uuid_str)

    def __init__(self, value):
        if isinstance(value, bytes) and len(value) == 16:
            self._uuid = uuid.UUID(bytes=value)
        elif isinstance(value, str):
            self._uuid = uuid.UUID(value)
        elif isinstance(value, uuid.UUID):
            self._uuid = value
        else:
            raise ValueError(f"Invalid UUID: {value}")

    @property
    def ok(self):
        return True

    @property
    def Bytes(self):
        return self._uuid.bytes

    @property
    def bytes(self):
        return self._uuid.bytes

    @property
    def LowerStr(self):
        return str(self._uuid).lower()

    @property
    def UpperStr(self):
        return str(self._uuid).upper().replace('-', '')


def NewUUID():
    return uuid.uuid4()


def NewBUUID():
    return uuid.uuid4().bytes


def Get16toBytes(val):
    if val is None:
        return None
    if isinstance(val, bytes) and len(val) == 16:
        return val
    if isinstance(val, str):
        try:
            return uuid.UUID(val).bytes
        except ValueError:
            return None
    if isinstance(val, uuid.UUID):
        return val.bytes
    return None


def GetBytesTo16(val):
    if val is None:
        return None
    if isinstance(val, bytes) and len(val) == 16:
        return str(uuid.UUID(bytes=val)).upper().replace('-', '')
    if isinstance(val, str):
        return val
    if isinstance(val, uuid.UUID):
        return str(val).upper().replace('-', '')
    return str(val)


def GenerateUUID():
    return uuid.uuid4().bytes


def openr(filepath):
    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            return f.read()
    except Exception:
        return ''


def openw(filepath, content):
    try:
        with open(filepath, 'w', encoding='utf-8') as f:
            f.write(content)
        return True
    except Exception:
        return False


def opena(filepath, content):
    try:
        with open(filepath, 'a', encoding='utf-8') as f:
            f.write(content)
        return True
    except Exception:
        return False


def JoinPath(*args):
    return os.path.join(*args)


def Is_UUID(u):
    try:
        uuid.UUID(str(u))
        return True
    except (ValueError, AttributeError):
        return False


def GetFileSha256(filepath):
    h = hashlib.sha256()
    try:
        with open(filepath, 'rb') as f:
            while chunk := f.read(8192):
                h.update(chunk)
        return h.hexdigest()
    except Exception:
        return None


class Cookie:
    _local = threading.local()

    @staticmethod
    def _get_pending():
        if not hasattr(Cookie._local, 'pending'):
            Cookie._local.pending = []
        return Cookie._local.pending

    @staticmethod
    def get(name, default=None):
        req = _get_current_request()
        if req:
            return req.COOKIES.get(name, default)
        return default

    @staticmethod
    def set(name, value, domain='.gvsds.com', max_age=30*24*60*60, path='/', httponly=False, samesite='None', secure=True):
        Cookie._get_pending().append({
            'name': name, 'value': value, 'domain': domain,
            'max_age': max_age, 'path': path, 'httponly': httponly, 'samesite': samesite, 'secure': secure,
        })

    @staticmethod
    def delete(name, path='/', domain='.gvsds.com'):
        Cookie._get_pending().append({
            'name': name, 'value': '', 'max_age': 0, 'path': path, 'domain': domain, 'secure': True, 'samesite': 'None',
        })

    @staticmethod
    def clear():
        Cookie._get_pending().clear()

    @staticmethod
    def _apply_to_response(response):
        pending = Cookie._get_pending()
        for cookie in pending:
            response.set_cookie(
                cookie['name'],
                cookie.get('value', ''),
                max_age=cookie.get('max_age', 30*24*60*60),
                path=cookie.get('path', '/'),
                domain=cookie.get('domain', '.gvsds.com'),
                secure=cookie.get('secure', True),
                httponly=cookie.get('httponly', False),
                samesite=cookie.get('samesite', 'None'),
            )
        pending.clear()


class IP:
    @staticmethod
    def Get(request=None):
        if request:
            xff = request.META.get('HTTP_X_FORWARDED_FOR', '')
            if xff:
                return xff.split(',')[0].strip()
            return request.META.get('REMOTE_ADDR', '')
        return '127.0.0.1'


class UGM:
    @staticmethod
    def GetELTUser(elt=None):
        try:
            request = _get_current_request()
            if not request:
                return None
            elt_token = request.COOKIES.get('ELToken')
            if not elt_token:
                return None
            elt_uuid = _uuid_to_bytes(elt_token)
            elt_obj = EphemeralToken.objects.filter(elt_uuid=elt_uuid, elt_status=1).first()
            if not elt_obj or elt_obj.is_expired():
                return None
            user = User.objects.filter(user_uuid=elt_obj.elt_user_uuid).first()
            return user
        except Exception as e:
            logger.exception("GetELTUser failed")
            return None

    @staticmethod
    def GetUserDataByUserUUID(user_uuid):
        try:
            return User.objects.get(user_uuid=_uuid_to_bytes(user_uuid))
        except User.DoesNotExist:
            return None

    @staticmethod
    def GetUserDataByUserName(username):
        try:
            return User.objects.get(user_name=username)
        except User.DoesNotExist:
            return None

    @staticmethod
    def CreateELT(user, MaxTime=30, Type=0, AllowIP=None):
        elt = EphemeralToken.objects.create(
            elt_uuid=NewBUUID(),
            elt_user_uuid=user.user_uuid if hasattr(user, 'user_uuid') else _uuid_to_bytes(user),
            elt_end_time=datetime.datetime.utcnow() + datetime.timedelta(days=MaxTime),
            elt_type=Type,
            elt_status=1,
        )
        return elt

    @staticmethod
    def GetUserAvatar(user):
        try:
            user_uuid = user.user_uuid if hasattr(user, 'user_uuid') else _uuid_to_bytes(user)
            return UserAvatar.objects.get(user_uuid=user_uuid)
        except UserAvatar.DoesNotExist:
            return None

    @staticmethod
    def VerifyELT(ELT=None):
        try:
            request = _get_current_request()
            if not request:
                return False
            elt_token = request.COOKIES.get('ELToken')
            if not elt_token:
                return False
            elt_uuid = _uuid_to_bytes(elt_token)
            elt_obj = EphemeralToken.objects.filter(elt_uuid=elt_uuid, elt_status=1).first()
            if not elt_obj or elt_obj.is_expired():
                return False
            return elt_obj
        except Exception:
            return False


def PermissionVerifier(permission, attributes):
    if not permission:
        return True
    user = UGM.GetELTUser()
    if not user:
        return False
    from gvsds.apps.gerp.models import UserABAC
    for attr in attributes:
        abac_match = UserABAC.objects.filter(
            user_uuid=user.user_uuid,
            hierarchical_permission_identifiers=attr
        ).first()
        if abac_match:
            continue
        rbac_result = user.has_permission(attr)
        if rbac_result:
            continue
        return False
    return True


_request_local = threading.local()


def _get_query_cache():
    if not hasattr(_request_local, 'query_cache'):
        _request_local.query_cache = {}
    return _request_local.query_cache


def _invalidate_query_cache(model_class=None):
    cache = getattr(_request_local, 'query_cache', None)
    if cache is None:
        return
    if model_class is None:
        cache.clear()
    else:
        keys_to_remove = [k for k in cache if k[0] == model_class]
        for k in keys_to_remove:
            del cache[k]


def _get_current_request():
    return getattr(_request_local, 'request', None)

def set_current_request(request):
    _request_local.request = request


def _get_db_session():
    session = getattr(_request_local, 'db_session', None)
    if session is None:
        session = _DBSession()
        _request_local.db_session = session
    return session


class _AggregateQuery:
    def __init__(self, model, *aggregates):
        self.model = model
        self.aggregates = aggregates
        self._filters_q = []
        self._filters_kwargs = {}

    def filter(self, *args, **kwargs):
        converted_kwargs = {}
        for key, val in kwargs.items():
            parts = key.split('__')
            parts[0] = _pascal_to_snake(parts[0])
            converted_kwargs['__'.join(parts)] = val
        self._filters_q.extend(args)
        self._filters_kwargs.update(converted_kwargs)
        return self

    def scalar(self):
        try:
            qs = self.model.objects.filter(*self._filters_q, **self._filters_kwargs)
            agg_names = [f'_agg_{i}' for i in range(len(self.aggregates))]
            result = qs.aggregate(**dict(zip(agg_names, self.aggregates)))
            if len(self.aggregates) == 1:
                return result.get(agg_names[0])
            return tuple(result[n] for n in agg_names)
        except Exception:
            return None

    def all(self):
        return self.scalar()

    def first(self):
        return self.scalar()


class _MultiTableRow:
    def __init__(self, values, field_names):
        for name, val in zip(field_names, values):
            setattr(self, name, val)


class _MultiTableQuery:
    def __init__(self, model, select_fields=None):
        self.model = model
        self._select_fields = select_fields or []
        self._joins = []
        self._outerjoins = []
        self._filters_q = []
        self._filters_kwargs = {}

    def join(self, target, condition=None):
        self._joins.append((target, condition))
        return self

    def outerjoin(self, target, condition=None):
        self._outerjoins.append((target, condition))
        return self

    def filter(self, *args, **kwargs):
        self._filters_q.extend(args)
        self._filters_kwargs.update(kwargs)
        return self

    def _remap_q(self, q):
        from django.db.models import Q as DjQ
        new_children = []
        for child in q.children:
            if isinstance(child, DjQ):
                new_children.append(self._remap_q(child))
            elif isinstance(child, tuple):
                key, val = child
                new_key = self._remap_key(key)
                new_children.append((new_key, val))
            else:
                new_children.append(child)
        if new_children:
            new_q = DjQ(*new_children)
            new_q.connector = q.connector
            new_q.negated = q.negated
            return new_q
        return q

    def _remap_key(self, key):
        parts = key.split('__')
        field_name = parts[0]
        try:
            self.model._meta.get_field(field_name)
            return key
        except Exception:
            pass
        for joined_model, _ in self._joins + self._outerjoins:
            if not isinstance(joined_model, type):
                continue
            rel_path = self._find_relation_path(joined_model)
            if rel_path is None:
                continue
            base_field = field_name
            if base_field.endswith('_id'):
                base_field = base_field[:-3]
            try:
                joined_model._meta.get_field(base_field)
                if len(parts) > 1:
                    return f'{rel_path}__{base_field}__{"__".join(parts[1:])}'
                return f'{rel_path}__{base_field}'
            except Exception:
                pass
            for f in joined_model._meta.local_fields:
                pascal = snake_to_pascal(f.name)
                if pascal == field_name or pascal == base_field:
                    if len(parts) > 1:
                        return f'{rel_path}__{f.name}__{"__".join(parts[1:])}'
                    return f'{rel_path}__{f.name}'
        return key

    def _build_queryset(self):
        qs = self.model.objects.all()
        select_related_fields = []
        for target, condition in self._joins + self._outerjoins:
            if isinstance(target, type) and issubclass(target, django.db.models.Model):
                rel_path = self._find_relation_path(target)
                if rel_path is None:
                    continue
                is_forward_fk = False
                for f in self.model._meta.local_fields:
                    if hasattr(f, 'related_model') and f.related_model == target and f.name == rel_path:
                        is_forward_fk = True
                        break
                if is_forward_fk:
                    select_related_fields.append(rel_path)
        if select_related_fields:
            qs = qs.select_related(*select_related_fields)
        remapped_q = []
        for q in self._filters_q:
            from django.db.models import Q as DjQ
            if isinstance(q, DjQ):
                remapped_q.append(self._remap_q(q))
            else:
                remapped_q.append(q)
        remapped_kwargs = {}
        for k, v in self._filters_kwargs.items():
            remapped_kwargs[self._remap_key(k)] = v
        if remapped_q or remapped_kwargs:
            qs = qs.filter(*remapped_q, **remapped_kwargs)
        return qs

    def _find_relation_path(self, target_model):
        for rel in self.model._meta.get_fields():
            if hasattr(rel, 'related_model') and rel.related_model == target_model:
                if hasattr(rel, 'field'):
                    return rel.name
                if hasattr(rel, 'get_accessor_name'):
                    return rel.get_accessor_name()
        for f in self.model._meta.local_fields:
            if hasattr(f, 'related_model') and f.related_model == target_model:
                return f.name
        return None

    def _get_field_names(self):
        names = []
        for f in self._select_fields:
            raw_name = None
            if hasattr(f, '_django_name'):
                raw_name = f._django_name
            elif hasattr(f, 'field_name'):
                raw_name = f.field_name
            elif hasattr(f, '__name__'):
                raw_name = f.__name__
            else:
                raw_name = str(f)
            if raw_name.endswith('_id'):
                pascal = snake_to_pascal(raw_name[:-3])
            else:
                pascal = snake_to_pascal(raw_name)
            names.append(pascal)
        return names

    def _resolve_field_on_obj(self, obj, django_field):
        val = getattr(obj, django_field, None)
        if val is not None:
            return self._convert_uuid_field(obj, django_field, val)
        for f in self._select_fields:
            if hasattr(f, '_django_name') and f._django_name == django_field:
                if hasattr(f, 'model_class') and f.model_class != self.model:
                    target_model = f.model_class
                    rel_path = self._find_relation_path(target_model)
                    if rel_path:
                        related_obj = getattr(obj, rel_path, None)
                        if related_obj is not None:
                            val = getattr(related_obj, django_field, None)
                            if val is not None:
                                return self._convert_uuid_field(related_obj, django_field, val)
                break
        return None

    def _convert_uuid_field(self, obj, field_name, value):
        try:
            field = obj._meta.get_field(field_name)
            from gvsds.apps.core.models import UUIDField
            if isinstance(field, UUIDField) and isinstance(value, str):
                return uuid.UUID(value).bytes
        except Exception:
            pass
        if field_name.endswith('_id') and isinstance(value, str):
            try:
                uuid.UUID(value)
                return uuid.UUID(value).bytes
            except (ValueError, AttributeError):
                pass
        return value

    def all(self):
        qs = self._build_queryset()
        if self._select_fields:
            field_names = self._get_field_names()
            django_fields = []
            for f in self._select_fields:
                if hasattr(f, '_django_name'):
                    django_fields.append(f._django_name)
                elif hasattr(f, 'field_name'):
                    django_fields.append(f.field_name)
                else:
                    django_fields.append(str(f))
            results = []
            for obj in qs:
                values = [self._resolve_field_on_obj(obj, df) for df in django_fields]
                results.append(_MultiTableRow(values, field_names))
            return results
        return list(qs)

    def first(self):
        qs = self._build_queryset()
        obj = qs.first()
        if obj is None:
            return None
        if self._select_fields:
            field_names = self._get_field_names()
            django_fields = []
            for f in self._select_fields:
                if hasattr(f, '_django_name'):
                    django_fields.append(f._django_name)
                elif hasattr(f, 'field_name'):
                    django_fields.append(f.field_name)
                else:
                    django_fields.append(str(f))
            values = [self._resolve_field_on_obj(obj, df) for df in django_fields]
            return _MultiTableRow(values, field_names)
        return obj


class _DeleteStmt:
    def __init__(self, model_class, conditions=None):
        self.model_class = model_class
        self.conditions = conditions or Q()

    def where(self, *args, **kwargs):
        from django.db.models import Q
        new_conditions = Q()
        for a in args:
            if isinstance(a, Q):
                new_conditions &= a
        self.conditions = new_conditions
        return self

    def execute(self):
        if self.model_class and self.conditions:
            self.model_class.objects.filter(self.conditions).delete()
        elif self.model_class:
            self.model_class.objects.all().delete()


class _DBSession:
    def __init__(self):
        self._pending_adds = []
        self._pending_deletes = []
        self._tracked_instances = set()

    def add(self, obj):
        logger.debug(f"[DBSession.add] {obj.__class__.__name__} pk={getattr(obj, 'pk', '?')}")
        self._pending_adds.append(obj)

    def delete(self, obj):
        logger.debug(f"[DBSession.delete] {obj.__class__.__name__} pk={obj.pk}")
        self._pending_deletes.append(obj)
        self._tracked_instances.discard(obj)

    def track(self, obj):
        if isinstance(obj, django.db.models.Model):
            self._tracked_instances.add(obj)

    def commit(self):
        from django.db import transaction
        logger.debug(f"[DBSession.commit] deletes={len(self._pending_deletes)} adds={len(self._pending_adds)} tracked={len(self._tracked_instances)}")
        delete_pks = {(obj.__class__, obj.pk) for obj in self._pending_deletes if obj.pk is not None}
        with transaction.atomic():
            for obj in self._pending_deletes:
                pk = obj.pk
                model_name = obj.__class__.__name__
                result = obj.delete()
                logger.debug(f"[DBSession.commit] DELETE {model_name} pk={pk} result={result}")
            for obj in self._pending_adds:
                obj.save()
            for obj in self._tracked_instances:
                if obj.pk is not None and (obj.__class__, obj.pk) in delete_pks:
                    logger.debug(f"[DBSession.commit] SKIP save for deleted {obj.__class__.__name__} pk={obj.pk}")
                    continue
                try:
                    obj.save()
                except Exception as e:
                    logger.exception(f"[DBSession.commit] Failed to save {obj.__class__.__name__} pk={obj.pk}")
        self._pending_adds.clear()
        self._pending_deletes.clear()
        self._tracked_instances.clear()
        _invalidate_query_cache()

    def rollback(self):
        self._pending_adds.clear()
        self._pending_deletes.clear()
        self._tracked_instances.clear()
        _invalidate_query_cache()

    def execute(self, stmt):
        if isinstance(stmt, _DeleteStmt):
            stmt.execute()
        elif isinstance(stmt, str):
            from django.db import connection
            with connection.cursor() as cursor:
                cursor.execute(stmt)

    def query(self, *args):
        aggregates = []
        model = None
        select_fields = []
        for a in args:
            try:
                from gvsds.fsr import _AggregateExpr
                if isinstance(a, _AggregateExpr):
                    if a.model:
                        model = a.model
                    aggregates.append(a.aggregate)
                    continue
            except Exception:
                pass
            from django.db.models import Aggregate
            if isinstance(a, Aggregate):
                aggregates.append(a)
            elif isinstance(a, type) and issubclass(a, django.db.models.Model):
                model = a
            elif hasattr(a, '_django_name'):
                from gvsds.model_base import FieldExpression
                if isinstance(a, FieldExpression):
                    if a.model_class and model is None:
                        model = a.model_class
                    select_fields.append(a)
        if aggregates:
            return _AggregateQuery(model, *aggregates)
        if select_fields:
            return _MultiTableQuery(model, select_fields)
        if model:
            return _QueryCompat(model)
        return None


class _DB:
    @property
    def func(self):
        from gvsds.fsr import _CompatFunc
        if not hasattr(self, '_func_instance'):
            self._func_instance = _CompatFunc()
        return self._func_instance

    Float = float
    String = str

    @property
    def session(self):
        from gvsds.fluent import _get_session
        return _get_session()

    @staticmethod
    def or_(*args):
        from django.db.models import Q
        result = None
        for q in args:
            if isinstance(q, Q):
                if result is None:
                    result = q
                else:
                    result |= q
        return result if result is not None else Q()

    @staticmethod
    def and_(*args):
        from django.db.models import Q
        result = Q()
        for q in args:
            if isinstance(q, Q):
                result &= q
        return result


class _ValuesQueryCompat:
    def __init__(self, qs, fields):
        self._qs = qs
        self._fields = fields

    def filter(self, *args, **kwargs):
        self._qs = self._qs.filter(*args, **kwargs)
        return self

    def first(self):
        obj = self._qs.first()
        if obj is None:
            return None
        if len(self._fields) == 1:
            return getattr(obj, 'val0', None)
        return tuple(getattr(obj, f'val{i}', None) for i in range(len(self._fields)))

    def all(self):
        results = []
        for obj in self._qs:
            if len(self._fields) == 1:
                results.append(getattr(obj, 'val0', None))
            else:
                results.append(tuple(getattr(obj, f'val{i}', None) for i in range(len(self._fields))))
        return results

    def scalar(self):
        obj = self._qs.first()
        if obj is None:
            return None
        return getattr(obj, 'val0', None)


class _QueryCompat:
    def __init__(self, model_class):
        self.model = model_class
        self._qs = model_class.objects.all()
        self._joined_models = []
        self._patched_fks = []
        self._cache_enabled = True

    def _cache_key(self, method):
        qs = self._qs
        try:
            query_str = str(qs.query)
        except Exception:
            query_str = id(qs)
        return (self.model, method, query_str)

    def _ensure_reverse_relation(self, joined_model):
        for fk in joined_model._meta.local_fields:
            if not hasattr(fk, 'remote_field') or not fk.remote_field:
                continue
            if fk.remote_field.related_name == '+' and fk.remote_field.model == self.model:
                rel_name = joined_model._meta.model_name
                fk.remote_field.related_name = rel_name
                self._patched_fks.append((fk, '+'))

    def _restore_fks(self):
        for fk, original in self._patched_fks:
            fk.remote_field.related_name = original
        self._patched_fks.clear()

    def _convert_kwargs(self, kwargs):
        django_kwargs = {}
        for key, val in kwargs.items():
            if key.endswith('__isnull'):
                django_kwargs[key] = val
            else:
                parts = key.split('__')
                parts[0] = _pascal_to_snake(parts[0])
                django_kwargs['__'.join(parts)] = val
        return django_kwargs

    def _find_rel_path(self, field_name):
        try:
            self.model._meta.get_field(field_name)
            return None
        except Exception:
            pass
        lookup_name = field_name[:-3] if field_name.endswith('_id') else None
        for joined in self._joined_models:
            found = False
            try:
                joined._meta.get_field(field_name)
                found = True
            except Exception:
                if lookup_name:
                    try:
                        joined._meta.get_field(lookup_name)
                        found = True
                    except Exception:
                        pass
            if not found:
                continue
            for rel in self.model._meta.get_fields(include_hidden=True):
                if hasattr(rel, 'related_model') and rel.related_model == joined:
                    if hasattr(rel, 'get_accessor_name'):
                        acc = rel.get_accessor_name()
                        if acc != '+':
                            return acc
                    if hasattr(rel, 'name') and rel.name != '+':
                        return rel.name
            return joined._meta.model_name
        return None

    def _remap_q(self, q):
        from django.db.models import Q as DjQ
        new_children = []
        for child in q.children:
            if isinstance(child, DjQ):
                new_children.append(self._remap_q(child))
            elif isinstance(child, tuple):
                key, val = child
                new_key = self._remap_key(key)
                new_children.append((new_key, val))
            else:
                new_children.append(child)
        if new_children:
            new_q = DjQ(*new_children)
            new_q.connector = q.connector
            new_q.negated = q.negated
            return new_q
        return q

    def _remap_key(self, key):
        parts = key.split('__')
        field_name = parts[0]
        try:
            self.model._meta.get_field(field_name)
            return key
        except Exception:
            pass
        rel_path = self._find_rel_path(field_name)
        if rel_path:
            return rel_path + '__' + key
        return key

    def filter(self, *args, **kwargs):
        converted_args = []
        for arg in args:
            from django.db.models import Q as DjQ
            if isinstance(arg, DjQ) and self._joined_models:
                converted_args.append(self._remap_q(arg))
            else:
                converted_args.append(arg)
        django_kwargs = self._convert_kwargs(kwargs)
        self._qs = self._qs.filter(*converted_args, **django_kwargs)
        return self

    def order_by(self, *args):
        converted = []
        for a in args:
            if isinstance(a, str):
                if a.startswith('-'):
                    converted.append('-' + _pascal_to_snake(a[1:]))
                else:
                    converted.append(_pascal_to_snake(a))
            else:
                converted.append(str(a))
        self._qs = self._qs.order_by(*converted)
        return self

    def first(self):
        if self._cache_enabled:
            cache = _get_query_cache()
            key = self._cache_key('first')
            if key in cache:
                return cache[key]
        obj = self._qs.first()
        if obj is not None:
            _get_db_session().track(obj)
        if self._cache_enabled:
            _get_query_cache()[self._cache_key('first')] = obj
        return obj

    def all(self):
        if self._cache_enabled:
            cache = _get_query_cache()
            key = self._cache_key('all')
            if key in cache:
                return cache[key]
        results = list(self._qs)
        session = _get_db_session()
        for obj in results:
            session.track(obj)
        if self._cache_enabled:
            _get_query_cache()[self._cache_key('all')] = results
        return results

    def count(self):
        if self._cache_enabled:
            cache = _get_query_cache()
            key = self._cache_key('count')
            if key in cache:
                return cache[key]
        result = self._qs.count()
        if self._cache_enabled:
            _get_query_cache()[self._cache_key('count')] = result
        return result

    def get(self, **kwargs):
        django_kwargs = self._convert_kwargs(kwargs)
        obj = self._qs.get(**django_kwargs)
        _get_db_session().track(obj)
        return obj

    def limit(self, n):
        self._qs = self._qs[:n]
        return self

    def offset(self, n):
        self._qs = self._qs[n:]
        return self

    def join(self, *args, **kwargs):
        for arg in args:
            if isinstance(arg, type) and issubclass(arg, django.db.models.Model):
                if arg not in self._joined_models:
                    self._joined_models.append(arg)
                    self._ensure_reverse_relation(arg)
        return self

    def values(self, *fields):
        qs = self._qs
        annotations = {}
        for i, f in enumerate(fields):
            from gvsds.fsr import _AggregateExpr
            if isinstance(f, _AggregateExpr):
                annotations[f'val{i}'] = f.aggregate
            elif isinstance(f, (django.db.models.Aggregate, django.db.models.Expression)):
                annotations[f'val{i}'] = f
        if annotations:
            qs = qs.annotate(**annotations)
        return _ValuesQueryCompat(qs, fields)

    def update(self, values):
        if isinstance(values, dict):
            converted = {}
            for k, v in values.items():
                converted[_pascal_to_snake(k)] = v
            return self._qs.update(**converted)
        return 0

    def delete(self):
        return self._qs.delete()

    def params(self, **kwargs):
        return self

    def paginate(self, page=1, per_page=20, error_out=False):
        from django.core.paginator import Paginator
        if not self._qs.ordered:
            meta = getattr(self.model, '_meta', None)
            if meta and meta.pk:
                self._qs = self._qs.order_by(meta.pk.name)
        paginator = Paginator(self._qs, per_page)
        try:
            page_obj = paginator.page(page)
        except Exception:
            page_obj = paginator.page(1)
        page_obj.total = paginator.count
        page_obj.items = page_obj.object_list
        page_obj.pages = paginator.num_pages
        page_obj.page = page
        page_obj.per_page = per_page
        page_obj.has_next = page_obj.has_next()
        page_obj.has_prev = page_obj.has_previous()
        page_obj.next_num = page_obj.next_page_number() if page_obj.has_next else None
        page_obj.prev_num = page_obj.previous_page_number() if page_obj.has_prev else None
        return page_obj


def _add_query_compat_to_models():
    from gvsds.apps.crb.models import Enterprise, EnterpriseUser
    for model in [User, Company, Department, Role, UserRole, RoleDept,
                  Permission, FileAsset, WorkOrder, Message, Menu,
                  Tenant, CompanyInfo, Enterprise, EnterpriseUser]:
        if not hasattr(model, 'query'):
            model.query = type('query', (), {
                '__getattr__': lambda self, name: getattr(_QueryCompat(model), name)
            })()


db = _DB()

GetELTUser = UGM.GetELTUser


def Gender2Str(c):
    if c == -1:
        return "未更改"
    elif c == 1:
        return "男"
    elif c == 0:
        return "女"
    else:
        return "错误"


import smtplib
import email.mime.text
import email.mime.multipart
import email.header
import email.encoders
from email.mime.base import MIMEBase


class EmailSender:
    def __init__(self, smtpServer, smtpPort, senderEmail, senderPassword, senderName=None):
        self.SmtpServer = smtpServer
        self.SmtpPort = smtpPort
        self.SenderEmail = senderEmail
        self.SenderPassword = senderPassword
        self.SenderName = senderName if senderName else senderEmail
        self.FromHeader = f"{email.header.Header(self.SenderName, 'utf-8')}"

    def SendTextEmail(self, receiverEmails, subject, content):
        msg = email.mime.text.MIMEText(content, 'plain', 'utf-8')
        msg['From'] = self.FromHeader
        msg['To'] = ','.join(receiverEmails)
        msg['Subject'] = email.header.Header(subject, 'utf-8')
        try:
            with smtplib.SMTP_SSL(self.SmtpServer, self.SmtpPort) as server:
                server.login(self.SenderEmail, self.SenderPassword)
                server.sendmail(self.SenderEmail, receiverEmails, msg.as_string())
            return True
        except Exception as e:
            logger.error(f"发送文本邮件失败: {str(e)}")
            return False

    def SendHtmlEmail(self, receiverEmails, subject, htmlContent):
        msg = email.mime.text.MIMEText(htmlContent, 'html', 'utf-8')
        msg['From'] = self.FromHeader
        msg['To'] = ','.join(receiverEmails)
        msg['Subject'] = email.header.Header(subject, 'utf-8')
        try:
            with smtplib.SMTP_SSL(self.SmtpServer, self.SmtpPort) as server:
                server.login(self.SenderEmail, self.SenderPassword)
                server.sendmail(self.SenderEmail, receiverEmails, msg.as_string())
            return True
        except Exception as e:
            logger.error(f"发送HTML邮件失败: {str(e)}")
            return False


def NonLegalChar(s):
    errors = r"\/:*?" + '"' + "<>!@#$%^&*()【】|、{}《》，。,."
    for c in str(s):
        if c in errors:
            return True
    return False


class BadH:
    pass


class StoreValueRule:
    pass