from rest_framework import serializers
from .models import FlightInventory, AirLineInventory, AirLinePrice, CancellationRules, AirLinePriceHistory, \
    AirLinePriceUpdateHistory, agencyToAgencyMapping
from datetime import date


class AirLinePriceHistorySerializer(serializers.ModelSerializer):
    status = serializers.SerializerMethodField()
    cancellation_charge = serializers.SerializerMethodField()

    class Meta:
        model = AirLinePriceHistory

        fields = ('status', 'cancellation_charge')
        """
        fields = ('HistoryId', 'AirLinePrice', 'ReferenceNo', 'Adult', 'Child', 'Infant', 'Inventory',
                  'InventoryStatus', 'UpdatedDate', 'ReleasedDate', 'status', 'cancellation_charge')
        """

    def get_status(self, instance):
        return True

    def get_cancellation_charge(self, instance):
        return 600


class CancellationRulesSerializer(serializers.ModelSerializer):
    class Meta:
        model = CancellationRules
        fields = ('id', 'SecurityKey', 'AirLinePrice', 'Days', 'PercentageValue', 'FixedVal', 'IsMaster', 'CreatedDate',
                  'UpdatedDate', 'IsMarkForDelete')


class AirLinePriceSerializer(serializers.ModelSerializer):
    class Meta:
        model = AirLinePrice
        fields = ('id', 'IsRefundable', 'FromDate', 'OnwardGroupPNR', 'OnwardAutoTicket', 'InDate', 'InwardGroupPNR',
                  'InwardAutoTicket', 'Seats', 'Hold', 'Sold', 'CurrentSeat', 'MinimumBooking', 'CutOffDate', 'Fare',
                  'Taxes', 'MarkupType', 'B2CMarkup', 'Markup', 'InfantFare', 'InfantMarkup', 'IsActive')


class AirLineInventorySerializer(serializers.ModelSerializer):
    class Meta:
        model = AirLineInventory
        fields = ('id', 'FlightType', 'AirLines', 'FlightNumber', 'FromCityCode', 'FromTerminal', 'ToCityCode',
                  'ToTerminal', 'Stops', 'DepartureTime', 'EstimateHours', 'ArrivalTime')


class FlightInventorySerializer(serializers.ModelSerializer):
    airlineinventories = AirLineInventorySerializer(many=True)
    airlineprices = AirLinePriceSerializer(many=True)

    class Meta:
        model = FlightInventory
        fields = (
            'id', 'Title', 'SecurityKey', 'Title', 'FlightType', 'Supplier', 'Currency', 'CheckInLuggage',
            'InCabinLuggage',
            'Fare',
            'CancellationPolicy', 'InternalRemarks', 'IsActive', 'CreatedBy', 'CreatedOn', 'OnwardFromAirportCode',
            'OnwardToAirportCode', 'InwardFromAirportCode', 'InwardToAirportCode', 'airlineinventories',
            'airlineprices')

    def create(self, validated_data):
        temp_airline_inventories = validated_data.pop('airlineinventories')
        temp_airline_prices = validated_data.pop('airlineprices')
        new_book = FlightInventory.objects.create(**validated_data)
        for i in temp_airline_inventories:
            AirLineInventory.objects.create(**i, FlightInventory=new_book)
        for j in temp_airline_prices:
            AirLinePrice.objects.create(**j, FlightInventory=new_book)
        return new_book

    def update(self, instance, validated_data):
        temp_airline_prices = dict((i.id, i) for i in instance.airlineprices.all())
        temp_airline_inventories = dict((i.id, i) for i in instance.airlineinventories.all())
        request = self.context['request']
        airline_price = request.data.get('airlineprices', [])
        for airline_price_data in airline_price:
            if 'id' in airline_price_data:
                airline_price_obj = AirLinePrice.objects.filter(id=airline_price_data['id']).first()
            else:
                airline_price_obj = None
            if airline_price_obj is not None:
                temp_airline_prices.pop(int(airline_price_data['id']))
                airline_serializer = AirLinePriceSerializer(airline_price_obj, data=airline_price_data)
                if airline_serializer.is_valid():
                    if 'CurrentSeat' not in airline_price_data or int(airline_price_data['CurrentSeat']) >= 0:
                        airline_serializer.save()
            else:
                AirLinePrice.objects.create(FlightInventory=instance, **airline_price_data)

        if len(temp_airline_prices) > 0:
            for price_data in temp_airline_prices.values():
                price_data.delete()

        airline_inventory = request.data.get('airlineinventories', [])
        for airline_inventory_data in airline_inventory:
            if 'id' in airline_inventory_data:
                airline_inventory_obj = AirLineInventory.objects.filter(id=airline_inventory_data['id']).first()
            else:
                airline_inventory_obj = None
            if airline_inventory_obj is not None:
                temp_airline_inventories.pop(int(airline_inventory_data['id']))
                airline_inventory_serializer = AirLineInventorySerializer(airline_inventory_obj,
                                                                          data=airline_inventory_data)
                if airline_inventory_serializer.is_valid():
                    airline_inventory_serializer.save()
            else:
                AirLineInventory.objects.create(FlightInventory=instance, **airline_inventory_data)

        if len(temp_airline_inventories) > 0:
            for air_inventory_data in temp_airline_inventories.values():
                air_inventory_data.delete()

        instance.__dict__.update(validated_data)
        instance.save()
        return instance


class IsDeleteFlightInventorySerializer(serializers.ModelSerializer):
    class Meta:
        model = FlightInventory
        fields = ('IsMarkForDelete',)

    def update(self, instance, validated_data):
        request = self.context['request']
        instance.IsMarkForDelete = request.data.get('IsMarkForDelete', instance.SecurityKey)
        instance.save()
        return instance


class UpdateIsRefundableAirLinePriceSerializer(serializers.ModelSerializer):
    class Meta:
        model = AirLinePrice
        fields = ('IsRefundable',)

    def update(self, instance, validated_data):
        request = self.context['request']
        instance.IsRefundable = request.data.get('IsRefundable', 0)
        instance.save()
        return instance


class AirLinePriceUpdateHistorySerializer(serializers.ModelSerializer):
    class Meta:
        model = AirLinePriceUpdateHistory
        fields = ('PSeat', 'PHold', 'PSold', 'PCurrent', 'AvailableSeat')


class AgencyToAgencyMappingSerializer(serializers.ModelSerializer):
    class Meta:
        model = agencyToAgencyMapping
        fields = ('SecurityKey', 'MasterSecurityKey')

    def create(self, validated_data):
        request = self.context['request']
        security_key = request.data.get('SecurityKey', None)
        master_security_key = request.data.get('MasterSecurityKey', None)
        agency_mapping_list = agencyToAgencyMapping.objects.filter(SecurityKey=security_key,
                                                                   MasterSecurityKey=master_security_key).first()
        new_book = []
        if agency_mapping_list is None:
            new_book = agencyToAgencyMapping.objects.create(**validated_data)
        return new_book


class UpdateSeatInPriceTableSerializer(serializers.ModelSerializer):
    class Meta:
        model = AirLinePrice
        fields = ('CurrentSeat', 'Hold', 'Seats', 'Sold',)
        read_only_fields = ('Hold', 'Seats', 'Sold',)

    def to_representation(self, instance):
        if self.context['request'].method in ['PATCH', 'PUT']:
            if type(instance) == dict:
                return instance
        return super().to_representation(instance)

    def update(self, instance, validated_data):
        return_status = True
        result = {}
        instance1 = instance
        airline_price_update_history_data = {}
        request = self.context['request']
        security_key = request.data.get('securityKey', None)
        # data = super(UpdateSeatInPriceTableSerializer, self).to_representation(instance)
        available_seat = int(request.data.get('CurrentSeat', 0))
        previous_seats = int(instance.Seats)
        previous_sold_seats = int(instance.Sold)
        previous_hold_seats = int(instance.Hold)
        previous_current_seats = int(instance.CurrentSeat)
        previous_current_seat_with_hold = previous_current_seats + previous_hold_seats
        if previous_current_seat_with_hold > available_seat:
            check_inventory = previous_current_seats - (previous_current_seat_with_hold - available_seat)
            if check_inventory >= 0:
                instance.CurrentSeat = check_inventory
                instance.Seats = previous_seats - (previous_current_seat_with_hold - available_seat)
                instance.save()
                airline_price_update_history_data['PSeat'] = previous_seats
                airline_price_update_history_data['PHold'] = previous_hold_seats
                airline_price_update_history_data['PSold'] = previous_sold_seats
                airline_price_update_history_data['PCurrent'] = previous_current_seats
                airline_price_update_history_data['AvailableSeat'] = available_seat
                AirLinePriceUpdateHistory.objects.create(AirLinePrice=instance1, **airline_price_update_history_data)
                return_status = True
            else:
                return_status = False
        elif available_seat > previous_current_seat_with_hold:
            calculate_price = (available_seat - (previous_hold_seats + previous_current_seats))
            instance.CurrentSeat = previous_current_seats + calculate_price
            instance.Seats = (previous_seats + calculate_price)
            instance.save()
            airline_price_update_history_data['PSeat'] = previous_seats
            airline_price_update_history_data['PHold'] = previous_hold_seats
            airline_price_update_history_data['PSold'] = previous_sold_seats
            airline_price_update_history_data['PCurrent'] = previous_current_seats
            airline_price_update_history_data['AvailableSeat'] = available_seat
            AirLinePriceUpdateHistory.objects.create(AirLinePrice=instance1, **airline_price_update_history_data)
            return_status = True
        return {'status': return_status, "CurrentSeat": instance.CurrentSeat, "Hold": instance.Hold,
                "Seats": instance.Seats, "Sold": instance.Sold}