"""日结模块统计服务函数"""
import logging
from datetime import datetime, date, time, timedelta
from decimal import Decimal, InvalidOperation

from django.db.models import Prefetch
from django.db.models import Q, Sum, Case, When, Value, CharField, IntegerField, Count
from django.db.models.fields.json import KeyTextTransform
from django.db.models.functions import Concat
from django.utils.dateparse import parse_datetime
from django.utils import timezone

from printing.models import PlateOrder
from stateflow.models import StateFlowRecord, StateLogParameterRecord

logger = logging.getLogger(__name__)

DEFAULT_DESIGNER_SUMMARY_STATE_NAMES = ("画图完成",)
DEFAULT_DESIGNER_TASK_STATE_NAME_SUFFIX = "完成"
DEFAULT_DESIGNER_PARAM_KEY = "设计师名称"
DEFAULT_DESIGNER_TASK_QUANTITY_PARAM_KEY = "完成数量"
DEFAULT_DESIGNER_TASK_TIME_PARAM_KEY = "完成时间"
DEFAULT_EMPTY_TASK_QUANTITY = Decimal("1")


def get_plate_order_summary_by_customer(
    merchant_id: int,
    settlement_date: date,
    user=None
) -> list[dict]:
    """
    获取按客户分组的开版订单统计
    
    Args:
        merchant_id: 商户ID
        settlement_date: 统计日期
        user: 当前用户（用于客户可见性过滤）
    
    Returns:
        list[dict]: 客户统计列表
    """
    logger.info(
        f'[settlement.services] 获取开版订单统计: '
        f'merchant_id={merchant_id}, date={settlement_date}'
    )

    settlement_date = _validate_and_normalize_summary_args(
        merchant_id=merchant_id,
        settlement_date=settlement_date,
    )
    
    queryset = _get_plate_order_queryset(merchant_id, user)
    aggregated_data = _aggregate_plate_orders_by_customer_and_type(
        queryset, settlement_date
    )
    return _format_plate_order_summary(aggregated_data)


def get_plate_order_summary_by_designer(
    merchant_id: int,
    settlement_date: date,
    user=None,
    state_names: list[str] | tuple[str, ...] | None = None,
    designer_param_key: str = DEFAULT_DESIGNER_PARAM_KEY,
) -> list[dict]:
    """
    获取按设计师分组的开版订单统计。

    设计师来源于 stateflow 参数记录，默认只统计“画图完成”节点下的
    ``parameters["设计师名称"]``。同一设计师在同一开版单同一类型下出现多次只计 1 单。
    """
    logger.info(
        f'[settlement.services] 获取开版订单设计师统计: '
        f'merchant_id={merchant_id}, date={settlement_date}, states={state_names}'
    )

    settlement_date = _validate_and_normalize_summary_args(
        merchant_id=merchant_id,
        settlement_date=settlement_date,
    )
    normalized_state_names = _normalize_designer_summary_state_names(state_names)
    if not designer_param_key or not str(designer_param_key).strip():
        raise ValueError('designer_param_key 不能为空')

    month_start_dt, next_day_dt, today_start_dt = _get_summary_datetime_ranges(
        settlement_date
    )
    queryset = _get_designer_plate_order_queryset(
        merchant_id=merchant_id,
        user=user,
        state_names=normalized_state_names,
        designer_param_key=designer_param_key,
        month_start_dt=month_start_dt,
        next_day_dt=next_day_dt,
    )
    aggregated_data = _aggregate_plate_orders_by_designer_and_type(
        queryset=queryset,
        today_start_dt=today_start_dt,
        next_day_dt=next_day_dt,
    )
    return _format_plate_order_designer_summary(aggregated_data)


def get_designer_workflow_task_summary(
    merchant_id: int,
    settlement_date: date,
    user=None,
    state_names: list[str] | tuple[str, ...] | None = None,
    designer_names: list[str] | tuple[str, ...] | None = None,
    designer_param_key: str = DEFAULT_DESIGNER_PARAM_KEY,
    quantity_param_key: str = DEFAULT_DESIGNER_TASK_QUANTITY_PARAM_KEY,
    time_param_key: str = DEFAULT_DESIGNER_TASK_TIME_PARAM_KEY,
) -> list[dict]:
    """
    获取设计师工序任务量统计。

    统计单位是未撤销的 StateFlowRecord。每条状态流转记录最多计入一次，
    即使其下存在多条 StateLogParameterRecord。
    """
    logger.info(
        f'[settlement.services] 获取设计师工序任务量统计: '
        f'merchant_id={merchant_id}, date={settlement_date}, states={state_names}'
    )

    settlement_date = _validate_and_normalize_summary_args(
        merchant_id=merchant_id,
        settlement_date=settlement_date,
    )
    normalized_state_names = _normalize_optional_state_names(state_names)
    normalized_designer_names = _normalize_optional_names(designer_names)
    for key, label in [
        (designer_param_key, 'designer_param_key'),
        (quantity_param_key, 'quantity_param_key'),
        (time_param_key, 'time_param_key'),
    ]:
        if not key or not str(key).strip():
            raise ValueError(f'{label} 不能为空')

    month_start_dt, next_day_dt, today_start_dt = _get_summary_datetime_ranges(
        settlement_date
    )
    queryset = _get_designer_workflow_task_queryset(
        merchant_id=merchant_id,
        user=user,
        state_names=normalized_state_names,
        designer_param_key=designer_param_key,
    )
    summary = _aggregate_designer_workflow_tasks(
        queryset=queryset,
        month_start_dt=month_start_dt,
        today_start_dt=today_start_dt,
        next_day_dt=next_day_dt,
        designer_names=normalized_designer_names,
        designer_param_key=designer_param_key,
        quantity_param_key=quantity_param_key,
        time_param_key=time_param_key,
    )
    return _format_designer_workflow_task_summary(summary)


def _normalize_optional_names(
    names: list[str] | tuple[str, ...] | None,
) -> tuple[str, ...] | None:
    if names is None:
        return None
    normalized = tuple(name.strip() for name in names if isinstance(name, str) and name.strip())
    if not normalized:
        raise ValueError('designer_names 不能为空')
    return normalized


def _normalize_optional_state_names(
    state_names: list[str] | tuple[str, ...] | None,
) -> tuple[str, ...] | None:
    if state_names is None:
        return None
    normalized = tuple(
        name.strip() for name in state_names if isinstance(name, str) and name.strip()
    )
    if not normalized:
        raise ValueError('state_names 不能为空')
    return normalized


def _normalize_designer_summary_state_names(
    state_names: list[str] | tuple[str, ...] | None,
) -> tuple[str, ...]:
    """标准化设计师统计节点名。"""
    if state_names is None:
        return DEFAULT_DESIGNER_SUMMARY_STATE_NAMES

    normalized = tuple(
        name.strip() for name in state_names if isinstance(name, str) and name.strip()
    )
    if not normalized:
        raise ValueError('state_names 不能为空')
    return normalized


def _get_summary_datetime_ranges(settlement_date: date):
    """返回月初、次日、当天起始的当前时区 aware datetime。"""
    current_tz = timezone.get_current_timezone()
    month_start = settlement_date.replace(day=1)
    month_start_dt = timezone.make_aware(
        datetime.combine(month_start, time.min), current_tz
    )
    today_start_dt = timezone.make_aware(
        datetime.combine(settlement_date, time.min), current_tz
    )
    next_day_dt = timezone.make_aware(
        datetime.combine(settlement_date + timedelta(days=1), time.min), current_tz
    )
    return month_start_dt, next_day_dt, today_start_dt


def _get_designer_workflow_task_queryset(
    *,
    merchant_id: int,
    user=None,
    state_names: tuple[str, ...] | None,
    designer_param_key: str,
):
    queryset = StateFlowRecord.objects.filter(
        is_cancelled=False,
        business_object__plate_order__merchant_id=merchant_id,
        business_object__plate_order__plate_type__isnull=False,
        business_object__plate_order__production_method__isnull=False,
        parameter_records__parameters__has_key=designer_param_key,
    ).select_related(
        'state',
        'business_object__plate_order',
        'business_object__plate_order__customer',
    ).prefetch_related(
        Prefetch(
            'parameter_records',
            queryset=StateLogParameterRecord.objects.order_by('created_at', 'id'),
            to_attr='_prefetched_parameter_records',
        )
    ).distinct()

    if state_names is None:
        queryset = queryset.filter(state__name__endswith=DEFAULT_DESIGNER_TASK_STATE_NAME_SUFFIX)
    else:
        queryset = queryset.filter(state__name__in=state_names)

    if user and not user.is_superuser:
        emp = getattr(user, 'employee', None)
        if emp:
            queryset = queryset.filter(
                Q(business_object__plate_order__customer__created_by=emp) |
                Q(business_object__plate_order__customer__visible_employees=emp)
            ).distinct()

    return queryset.order_by('id')


def _aggregate_designer_workflow_tasks(
    *,
    queryset,
    month_start_dt: datetime,
    today_start_dt: datetime,
    next_day_dt: datetime,
    designer_names: tuple[str, ...] | None,
    designer_param_key: str,
    quantity_param_key: str,
    time_param_key: str,
) -> dict[tuple[str, str, str], dict[str, Decimal]]:
    summary: dict[tuple[str, str, str], dict[str, Decimal]] = {}
    designer_name_filter = set(designer_names) if designer_names is not None else None

    for state_log in queryset:
        parameters = _merge_state_log_parameters(state_log)
        designer_name = str(parameters.get(designer_param_key) or '').strip()
        if not designer_name:
            continue
        if designer_name_filter is not None and designer_name not in designer_name_filter:
            continue

        effective_time = _resolve_task_effective_time(
            parameters.get(time_param_key),
            fallback=state_log.completed_at,
        )
        if effective_time is None or effective_time < month_start_dt or effective_time >= next_day_dt:
            continue

        plate_order = state_log.business_object.plate_order
        task_quantity = _parse_task_quantity(parameters.get(quantity_param_key))
        key = (
            designer_name,
            state_log.state.name,
            f'{plate_order.plate_type}-{plate_order.production_method}',
        )
        if key not in summary:
            summary[key] = {'today': Decimal('0'), 'current_month': Decimal('0')}

        summary[key]['current_month'] += task_quantity
        if today_start_dt <= effective_time < next_day_dt:
            summary[key]['today'] += task_quantity

    return summary


def _merge_state_log_parameters(state_log: StateFlowRecord) -> dict:
    records = getattr(state_log, '_prefetched_parameter_records', None)
    if records is None:
        records = state_log.parameter_records.all().order_by('created_at', 'id')

    merged = {}
    for record in records:
        if isinstance(record.parameters, dict):
            merged.update(record.parameters)
    return merged


def _parse_task_quantity(value) -> Decimal:
    try:
        quantity = Decimal(str(value).strip())
    except (InvalidOperation, ValueError, TypeError, AttributeError):
        return DEFAULT_EMPTY_TASK_QUANTITY
    if quantity > 0:
        return quantity
    return DEFAULT_EMPTY_TASK_QUANTITY


def _resolve_task_effective_time(value, *, fallback):
    parsed = None
    if isinstance(value, datetime):
        parsed = value
    elif isinstance(value, str) and value.strip():
        raw_value = value.strip()
        parsed = parse_datetime(raw_value)
        if parsed is None:
            for fmt in ('%Y-%m-%d %H:%M:%S', '%Y-%m-%d %H:%M', '%Y-%m-%d'):
                try:
                    parsed = datetime.strptime(raw_value, fmt)
                    break
                except ValueError:
                    continue

    effective = parsed or fallback
    if effective is None:
        return None
    if timezone.is_naive(effective):
        effective = timezone.make_aware(effective, timezone.get_current_timezone())
    return effective.astimezone(timezone.get_current_timezone())


def _format_decimal_quantity(value: Decimal):
    if value == value.to_integral_value():
        return int(value)
    return str(value.normalize())


def _format_designer_workflow_task_summary(
    summary: dict[tuple[str, str, str], dict[str, Decimal]],
) -> list[dict]:
    result: dict[str, dict] = {}
    for (designer_name, state_name, type_name), counts in sorted(summary.items()):
        if designer_name not in result:
            result[designer_name] = {
                'designer_name': designer_name,
                'task_count': [],
                'today': Decimal('0'),
                'current_month': Decimal('0'),
            }
        result[designer_name]['task_count'].append({
            'state_name': state_name,
            'type': type_name,
            'today': _format_decimal_quantity(counts['today']),
            'current_month': _format_decimal_quantity(counts['current_month']),
        })
        result[designer_name]['today'] += counts['today']
        result[designer_name]['current_month'] += counts['current_month']

    formatted = []
    for item in result.values():
        item['today'] = _format_decimal_quantity(item['today'])
        item['current_month'] = _format_decimal_quantity(item['current_month'])
        formatted.append(item)
    return formatted


def _get_designer_plate_order_queryset(
    *,
    merchant_id: int,
    user=None,
    state_names: tuple[str, ...],
    designer_param_key: str,
    month_start_dt: datetime,
    next_day_dt: datetime,
):
    """获取设计师统计的 stateflow 参数记录基础查询集。"""
    queryset = StateLogParameterRecord.objects.filter(
        parameters__has_key=designer_param_key,
        state_log__is_cancelled=False,
        state_log__state__name__in=state_names,
        state_log__business_object__plate_order__merchant_id=merchant_id,
        state_log__business_object__plate_order__plate_type__isnull=False,
        state_log__business_object__plate_order__production_method__isnull=False,
        state_log__business_object__plate_order__plate_date__gte=month_start_dt,
        state_log__business_object__plate_order__plate_date__lt=next_day_dt,
    ).annotate(
        designer_name=KeyTextTransform(designer_param_key, 'parameters'),
        type=Concat(
            'state_log__business_object__plate_order__plate_type',
            Value('-'),
            'state_log__business_object__plate_order__production_method',
            output_field=CharField(),
        ),
    ).exclude(
        designer_name__isnull=True,
    ).exclude(
        designer_name='',
    )

    if user and not user.is_superuser:
        emp = getattr(user, 'employee', None)
        if emp:
            queryset = queryset.filter(
                Q(state_log__business_object__plate_order__customer__created_by=emp) |
                Q(state_log__business_object__plate_order__customer__visible_employees=emp)
            ).distinct()

    return queryset


def _aggregate_plate_orders_by_designer_and_type(
    *,
    queryset,
    today_start_dt: datetime,
    next_day_dt: datetime,
):
    """按设计师和类型聚合开版订单数量。"""
    plate_order_path = 'state_log__business_object__plate_order'
    return queryset.values(
        'designer_name',
        'type',
    ).annotate(
        today=Count(
            plate_order_path,
            filter=Q(
                state_log__business_object__plate_order__plate_date__gte=today_start_dt,
                state_log__business_object__plate_order__plate_date__lt=next_day_dt,
            ),
            distinct=True,
        ),
        current_month=Count(
            plate_order_path,
            distinct=True,
        ),
    ).order_by('designer_name', 'type')


def _format_plate_order_designer_summary(aggregated_data):
    """格式化设计师聚合结果为 API 返回格式。"""
    result = {}

    for item in aggregated_data:
        designer_name = item['designer_name']
        if designer_name not in result:
            result[designer_name] = {
                'designer_name': designer_name,
                'plate_order_count': [],
            }

        result[designer_name]['plate_order_count'].append({
            'type': item['type'],
            'today': item['today'],
            'current_month': item['current_month'],
        })

    for designer_name in result:
        result[designer_name]['plate_order_count'] = _filter_zero_data(
            result[designer_name]['plate_order_count']
        )

    return [v for v in result.values() if v['plate_order_count']]


def _validate_and_normalize_summary_args(
    merchant_id: int,
    settlement_date: date,
) -> date:
    """校验并标准化统计参数。"""
    if not isinstance(merchant_id, int) or merchant_id <= 0:
        raise ValueError('merchant_id 必须为正整数')

    if isinstance(settlement_date, datetime):
        settlement_date = settlement_date.date()

    if not isinstance(settlement_date, date):
        raise ValueError('settlement_date 必须为 date 或 datetime 类型')

    return settlement_date


def _get_plate_order_queryset(merchant_id: int, user=None):
    """
    获取开版订单的基础查询集
    
    Args:
        merchant_id: 商户ID
        user: 当前用户（用于客户可见性过滤）
    
    Returns:
        QuerySet[PlateOrder]: 过滤后的查询集
    """
    queryset = PlateOrder.objects.filter(
        merchant_id=merchant_id,
        plate_type__isnull=False,
        production_method__isnull=False
    ).select_related('customer')
    
    if user and not user.is_superuser:
        emp = getattr(user, 'employee', None)
        if emp:
            visible_customer_filter = (
                Q(customer__created_by=emp) |
                Q(customer__visible_employees=emp)
            )
            no_customer_filter = Q(customer__isnull=True)
            queryset = queryset.filter(
                visible_customer_filter | no_customer_filter
            ).distinct()
    
    return queryset


def _get_month_date_range(settlement_date: date) -> tuple[date, date]:
    """
    获取从月初到指定日期的日期范围
    
    Args:
        settlement_date: 统计日期
    
    Returns:
        tuple[date, date]: (月初日期, 统计日期)
    """
    month_start = settlement_date.replace(day=1)
    return month_start, settlement_date


def _aggregate_plate_orders_by_customer_and_type(queryset, settlement_date: date):
    """
    按客户和类型分组聚合订单数据
    
    Args:
        queryset: 基础查询集
        settlement_date: 统计日期
    
    Returns:
        QuerySet[PlateOrder]: 添加了聚合标注的查询集
    """
    month_start, _ = _get_month_date_range(settlement_date)
    
    queryset = queryset.annotate(
        type=Concat(
            'plate_type',
            Value('-'),
            'production_method',
            output_field=CharField()
        )
    ).values(
        'customer__id',
        'customer__name',
        'type'
    ).annotate(
        today=Sum(
            Case(
                When(
                    plate_date__date=settlement_date,
                    then=1
                ),
                default=0,
                output_field=IntegerField()
            )
        ),
        current_month=Sum(
            Case(
                When(
                    plate_date__date__gte=month_start,
                    plate_date__date__lte=settlement_date,
                    then=1
                ),
                default=0,
                output_field=IntegerField()
            )
        )
    ).order_by('customer__name', 'customer__id', 'type')
    
    return queryset


def _format_plate_order_summary(aggregated_data):
    """
    格式化聚合结果为 API 返回格式
    
    Args:
        aggregated_data: 聚合后的查询集
    
    Returns:
        list[dict]: 格式化后的数据
    """
    result = {}
    
    for item in aggregated_data:
        client_id = item['customer__id']
        client_name = item['customer__name']
        client_key = (client_id, client_name)
        if client_key not in result:
            result[client_key] = {
                'client_id': client_id,
                'client_name': client_name,
                'plate_order_count': []
            }
        
        plate_order_count = {
            'type': item['type'],
            'today': item['today'],
            'current_month': item['current_month']
        }
        
        result[client_key]['plate_order_count'].append(plate_order_count)
    
    for client_key in result:
        result[client_key]['plate_order_count'] = _filter_zero_data(
            result[client_key]['plate_order_count']
        )
    
    return [v for k, v in result.items() if v['plate_order_count']]


def _filter_zero_data(plate_order_counts):
    """
    过滤全0数据
    
    Args:
        plate_order_counts: 订单统计列表
    
    Returns:
        list[dict]: 过滤后的列表
    """
    return [
        item for item in plate_order_counts
        if item['today'] > 0 or item['current_month'] > 0
    ]


def calculate_plate_order_daily_summary(
    merchant_id: int,
    settlement_date: datetime.date
) -> dict:
    """
    计算开版订单日结汇总（空壳实现）
    
    Args:
        merchant_id: 商户ID
        settlement_date: 结算日期
    
    Returns:
        dict: 统计结果（空壳）
    """
    logger.info(
        f'[settlement.services] 计算开版订单日结汇总: '
        f'merchant_id={merchant_id}, date={settlement_date}'
    )
    
    return {
        'merchant_id': merchant_id,
        'settlement_date': str(settlement_date),
        'total_orders': 0,
        'completed_orders': 0,
        'in_progress_orders': 0,
    }


def calculate_printing_order_daily_summary(
    merchant_id: int,
    settlement_date: datetime.date
) -> dict:
    """
    计算生产订单日结汇总（空壳实现）
    
    Args:
        merchant_id: 商户ID
        settlement_date: 结算日期
    
    Returns:
        dict: 统计结果（空壳）
    """
    logger.info(
        f'[settlement.services] 计算生产订单日结汇总: '
        f'merchant_id={merchant_id}, date={settlement_date}'
    )
    
    return {
        'merchant_id': merchant_id,
        'settlement_date': str(settlement_date),
        'total_orders': 0,
        'completed_orders': 0,
        'in_progress_orders': 0,
    }