"""后台 — 提现冻结配置/解冻接口"""
import logging

from django.db import transaction
from rest_framework.parsers import JSONParser
from rest_framework.response import Response
from rest_framework.views import APIView

from yonghu.freeze_service import (
    FREEZE_LEIXING_SET,
    admin_unfreeze_balance,
    get_public_freeze_settings,
    get_user_freeze_info,
    save_public_freeze_settings,
    save_user_freeze_settings,
)
from yonghu.models import UserMain

from .view import verify_kefu_permission

logger = logging.getLogger(__name__)

_WITHDRAW_PERMS = ('5500a', '5500b', '5500c')


def _check_withdraw_perm(permissions):
    return any(p in permissions for p in _WITHDRAW_PERMS)


class DongjieUserConfigView(APIView):
    """
    用户单独冻结配置 / 解冻（打手佣金1、管事2、押金5、商家6 共用）
    GET  POST /houtai/hqdjdongjie
    """
    permission_classes = []
    parser_classes = [JSONParser]

    def post(self, request):
        username = (request.data.get('username') or '').strip()
        action = (request.data.get('action') or 'get').strip()

        kefu, permissions = verify_kefu_permission(request, username)
        if kefu is None:
            return permissions
        if not _check_withdraw_perm(permissions):
            return Response({'code': 403, 'msg': '无权限操作冻结配置'})

        yonghuid = (request.data.get('yonghuid') or '').strip()
        leixing_raw = request.data.get('leixing')
        try:
            leixing = int(leixing_raw)
        except (TypeError, ValueError):
            return Response({'code': 400, 'msg': 'leixing 无效'})
        if leixing not in FREEZE_LEIXING_SET:
            return Response({'code': 400, 'msg': '该提现类型不支持冻结配置'})

        try:
            user_main = UserMain.objects.get(yonghuid=yonghuid)
        except UserMain.DoesNotExist:
            return Response({'code': 404, 'msg': '用户不存在'})

        if action == 'get':
            return Response({'code': 0, 'data': get_user_freeze_info(user_main, leixing)})

        if action == 'save':
            try:
                with transaction.atomic():
                    data = save_user_freeze_settings(user_main, leixing, request.data)
                    from yonghu.xiugai_log import (
                        write_xiugai_log, FREEZE_TO_XIUGAI_LEIXING, FREEZE_LEIXING_NAME,
                    )
                    role_name = FREEZE_LEIXING_NAME.get(leixing, str(leixing))
                    write_xiugai_log(
                        yonghuid=yonghuid,
                        operator_phone=kefu.user.phone,
                        leixing=FREEZE_TO_XIUGAI_LEIXING.get(leixing, 0),
                        qitashuoming=(
                            f'保存用户冻结配置[{role_name}]：'
                            f'单独开关={data.get("dandu_dongjie_enabled")}，'
                            f'模式={data.get("dongjie_mode")}，'
                            f'比例={data.get("dongjie_bili")}，'
                            f'固定额={data.get("dongjie_guding_jine")}'
                        ),
                    )
                return Response({'code': 0, 'msg': '保存成功', 'data': data})
            except ValueError as e:
                return Response({'code': 400, 'msg': str(e)})

        if action == 'unfreeze':
            jine = request.data.get('jiedong_jine') or request.data.get('jine')
            beizhu = (request.data.get('beizhu') or '').strip()
            if jine is None:
                return Response({'code': 400, 'msg': '请填写解冻金额'})
            try:
                with transaction.atomic():
                    result = admin_unfreeze_balance(
                        user_main, leixing, jine,
                        operator_id=username, beizhu=beizhu,
                    )
                    from yonghu.xiugai_log import (
                        write_xiugai_log, FREEZE_TO_XIUGAI_LEIXING, FREEZE_LEIXING_NAME,
                    )
                    role_name = FREEZE_LEIXING_NAME.get(leixing, str(leixing))
                    xiugai_leixing = FREEZE_TO_XIUGAI_LEIXING.get(leixing, 0)
                    log_kwargs = {
                        'yonghuid': yonghuid,
                        'operator_phone': kefu.user.phone,
                        'leixing': xiugai_leixing,
                        'qitashuoming': (
                            f'管理员解冻[{role_name}] {result["unfreeze_jine"]}，'
                            f'余额 {result["balance_before"]}→{result["balance_after"]}，'
                            f'冻结池 {result["dongjie_chi_before"]}→{result["dongjie_chi_after"]}'
                            + (f'；备注:{beizhu}' if beizhu else '')
                        ),
                    }
                    if leixing == 1:
                        log_kwargs['dashou_yue_before'] = result['balance_before']
                        log_kwargs['dashou_yue_after'] = result['balance_after']
                    elif leixing == 5:
                        log_kwargs['yajin_before'] = result['balance_before']
                        log_kwargs['yajin_after'] = result['balance_after']
                    elif leixing == 2:
                        log_kwargs['guanshi_yue_before'] = result['balance_before']
                        log_kwargs['guanshi_yue_after'] = result['balance_after']
                    elif leixing == 6:
                        log_kwargs['shangjia_yue_before'] = result['balance_before']
                        log_kwargs['shangjia_yue_after'] = result['balance_after']
                    write_xiugai_log(**log_kwargs)
                info = get_user_freeze_info(user_main, leixing)
                info['balance'] = str(result['balance_after'])
                info['dongjie_chi'] = str(result['dongjie_chi_after'])
                info['unfreeze_result'] = {
                    'balance_before': str(result['balance_before']),
                    'balance_after': str(result['balance_after']),
                    'dongjie_chi_before': str(result['dongjie_chi_before']),
                    'dongjie_chi_after': str(result['dongjie_chi_after']),
                    'unfreeze_jine': str(result['unfreeze_jine']),
                }
                return Response({'code': 0, 'msg': '解冻成功', 'data': info})
            except ValueError as e:
                return Response({'code': 400, 'msg': str(e)})

        return Response({'code': 400, 'msg': 'action 无效，支持 get/save/unfreeze'})