from decimal import Decimal

from django.db import transaction
from django.db.models import Sum

from apps.materials.stock_service import create_reserves_for_plan
from apps.materials.models import StockTransaction
from apps.workrecords.services import sync_spreading_work_record
from .models import FertilizationEntry, FertilizationPlan, SpreadingSessionItem


def sync_actual_bags_for_pairs(year, field_fertilizer_pairs):
    pairs = {
        (int(field_id), int(fertilizer_id))
        for field_id, fertilizer_id in field_fertilizer_pairs
    }
    if not pairs:
        return

    for field_id, fertilizer_id in pairs:
        total = (
            SpreadingSessionItem.objects.filter(
                session__year=year,
                field_id=field_id,
                fertilizer_id=fertilizer_id,
            ).aggregate(total=Sum('actual_bags'))['total']
        )
        FertilizationEntry.objects.filter(
            plan__year=year,
            field_id=field_id,
            fertilizer_id=fertilizer_id,
        ).update(actual_bags=total)


@transaction.atomic
def sync_spreading_session_side_effects(session, field_fertilizer_pairs):
    sync_actual_bags_for_pairs(session.year, field_fertilizer_pairs)
    sync_stock_uses_for_spreading_session(session)
    sync_spreading_work_record(session)


@transaction.atomic
def sync_stock_uses_for_spreading_session(session):
    StockTransaction.objects.filter(spreading_item__session=session).delete()

    session_items = session.items.select_related('fertilizer__material')
    for item in session_items:
        material = getattr(item.fertilizer, 'material', None)
        if material is None:
            continue
        StockTransaction.objects.create(
            material=material,
            transaction_type=StockTransaction.TransactionType.USE,
            quantity=item.actual_bags,
            occurred_on=session.date,
            note=f'散布実績「{session.name.strip() or session.date}」',
            fertilization_plan=None,
            spreading_item=item,
        )


@transaction.atomic
def move_fertilization_entries_for_variety_change(change):
    moved_count = 0
    old_variety_id = change.old_variety_id
    new_variety = change.new_variety
    if old_variety_id is None or new_variety is None:
        return 0

    old_plans = (
        FertilizationPlan.objects
        .filter(
            year=change.year,
            variety_id=old_variety_id,
            entries__field_id=change.field_id,
        )
        .distinct()
        .prefetch_related('entries')
    )

    for old_plan in old_plans:
        entries_to_move = list(
            old_plan.entries.filter(
                field_id=change.field_id,
            ).order_by('id')
        )
        if not entries_to_move:
            continue

        new_plan = FertilizationPlan.objects.create(
            name=f'{change.year}年度 {new_variety.name} 施肥計画（品種変更移動）',
            year=change.year,
            variety=new_variety,
            calc_settings=old_plan.calc_settings,
        )

        FertilizationEntry.objects.filter(
            id__in=[entry.id for entry in entries_to_move]
        ).update(plan=new_plan)

        create_reserves_for_plan(old_plan)
        create_reserves_for_plan(new_plan)
        moved_count += len(entries_to_move)

    return moved_count