from rest_framework import serializers
from .models import BusinessPlan, Investment, HumanResource, StartupCost, RevenueForecast, ExpenseForecast, MarketingActivity


def _truncate_charfields(data, model_class):
    """Tronque les champs CharField au max_length pour éviter 400 (ex. texte IA trop long)."""
    if not data or not isinstance(data, dict):
        return data
    out = dict(data)
    for field in model_class._meta.fields:
        if getattr(field, "max_length", None) is not None and field.name in out:
            val = out[field.name]
            if isinstance(val, str) and len(val) > field.max_length:
                out[field.name] = val[: field.max_length]
    return out


class MarketingActivitySerializer(serializers.ModelSerializer):
    class Meta:
        model = MarketingActivity
        fields = '__all__'
        read_only_fields = ['plan']


class InvestmentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Investment
        fields = '__all__'
        read_only_fields = ['plan']

class HumanResourceSerializer(serializers.ModelSerializer):
    class Meta:
        model = HumanResource
        fields = '__all__'
        read_only_fields = ['plan']

class StartupCostSerializer(serializers.ModelSerializer):
    class Meta:
        model = StartupCost
        fields = '__all__'
        read_only_fields = ['plan']

class RevenueForecastSerializer(serializers.ModelSerializer):
    class Meta:
        model = RevenueForecast
        fields = '__all__'
        read_only_fields = ['plan']

class ExpenseForecastSerializer(serializers.ModelSerializer):
    class Meta:
        model = ExpenseForecast
        fields = '__all__'
        read_only_fields = ['plan']

class BusinessPlanSerializer(serializers.ModelSerializer):
    marketing_activities = MarketingActivitySerializer(many=True, required=False)
    investments = InvestmentSerializer(many=True, required=False)
    human_resources = HumanResourceSerializer(many=True, required=False)
    startup_costs = StartupCostSerializer(many=True, required=False)
    revenues = RevenueForecastSerializer(many=True, required=False)
    expenses = ExpenseForecastSerializer(many=True, required=False)

    class Meta:
        model = BusinessPlan
        fields = '__all__'
        read_only_fields = ['entrepreneur']

    def to_internal_value(self, data):
        data = _truncate_charfields(data, BusinessPlan)
        return super().to_internal_value(data)

    def _save_nested(self, plan, attr, serializer_class, data_list):
        if data_list is None:
            return
        getattr(plan, attr).all().delete()
        for item in data_list:
            item = dict(item)
            item.pop('id', None)
            item.pop('plan', None)
            ser = serializer_class(data=item)
            ser.is_valid(raise_exception=True)
            ser.save(plan=plan)

    def create(self, validated_data):
        nested = {}
        for key in ('marketing_activities', 'investments', 'human_resources', 'startup_costs', 'revenues', 'expenses'):
            nested[key] = validated_data.pop(key, None)
        plan = super().create(validated_data)
        for key, data_list in nested.items():
            if key == 'marketing_activities' and data_list:
                self._save_nested(plan, 'marketing_activities', MarketingActivitySerializer, data_list)
            elif key == 'investments' and data_list:
                self._save_nested(plan, 'investments', InvestmentSerializer, data_list)
            elif key == 'human_resources' and data_list:
                self._save_nested(plan, 'human_resources', HumanResourceSerializer, data_list)
            elif key == 'startup_costs' and data_list:
                self._save_nested(plan, 'startup_costs', StartupCostSerializer, data_list)
            elif key == 'revenues' and data_list:
                self._save_nested(plan, 'revenues', RevenueForecastSerializer, data_list)
            elif key == 'expenses' and data_list:
                self._save_nested(plan, 'expenses', ExpenseForecastSerializer, data_list)
        return plan

    def update(self, instance, validated_data):
        nested = {}
        for key in ('marketing_activities', 'investments', 'human_resources', 'startup_costs', 'revenues', 'expenses'):
            nested[key] = validated_data.pop(key, None)
        plan = super().update(instance, validated_data)
        for key, data_list in nested.items():
            if key == 'marketing_activities' and data_list is not None:
                self._save_nested(plan, 'marketing_activities', MarketingActivitySerializer, data_list)
            elif key == 'investments' and data_list is not None:
                self._save_nested(plan, 'investments', InvestmentSerializer, data_list)
            elif key == 'human_resources' and data_list is not None:
                self._save_nested(plan, 'human_resources', HumanResourceSerializer, data_list)
            elif key == 'startup_costs' and data_list is not None:
                self._save_nested(plan, 'startup_costs', StartupCostSerializer, data_list)
            elif key == 'revenues' and data_list is not None:
                self._save_nested(plan, 'revenues', RevenueForecastSerializer, data_list)
            elif key == 'expenses' and data_list is not None:
                self._save_nested(plan, 'expenses', ExpenseForecastSerializer, data_list)
        return plan