from collections import OrderedDict
from typing import Any, List, Union

from rest_framework import serializers
from rest_framework.fields import SerializerMethodField

from .models import (ExclusiveProgram, Location, Program, Site,
                     UtilitySoftware, Workplace, WorkplaceType)


class ProgramSerializer(serializers.ModelSerializer[Program]):

    icon = SerializerMethodField()

    class Meta:
        model = Program
        fields = ('id', 'name', 'label', 'description', 'executable_path',
                  'fallback_path', 'parameters', 'window_process', 'icon',
                  'order')

    def get_icon(self, obj: Program) -> Union[str, Any]:
        return obj.icon.url if obj.icon else None


class UtilitySoftwareSerializer(serializers.ModelSerializer[UtilitySoftware]):
    icon = SerializerMethodField()

    class Meta:
        model = UtilitySoftware
        fields = ('id', 'name', 'label', 'description', 'executable_path',
                  'fallback_path', 'parameters', 'icon', 'order')

    def get_icon(self, obj: UtilitySoftware) -> Union[str, Any]:
        return obj.icon.url if obj.icon else None


class SiteSerializer(serializers.ModelSerializer[Site]):
    icon = SerializerMethodField()

    class Meta:
        model = Site
        fields = ('id', 'name', 'label', 'description', 'url', 'icon',
                  'open_with_default_browser', 'is_frameless', 'is_program',
                  'order')

    def get_icon(self, obj: Site) -> Union[str, Any]:
        return obj.icon.url if obj.icon else None


class WorkplaceTypeSerializer(serializers.ModelSerializer[WorkplaceType]):

    class Meta:
        model = WorkplaceType
        fields = (
            'id',
            'name',
            'description',
        )


class LocationShortSerializer(serializers.ModelSerializer[Location]):

    class Meta:
        model = Site
        fields = (
            'id',
            'name',
            'description',
        )


class WorkplaceTypeFullInfoSerializer(
        serializers.ModelSerializer[WorkplaceType]):
    programs = SerializerMethodField()
    utility_software = SerializerMethodField()
    sites = SerializerMethodField()
    location = LocationShortSerializer()
    password = SerializerMethodField()

    class Meta:
        model = WorkplaceType
        fields = ('name', 'description', 'location', 'password', 'programs',
                  'utility_software', 'sites', 'is_active')

    def get_programs(self, obj: WorkplaceType) -> OrderedDict[str, Any]:
        serializer = ProgramSerializer(obj.programs, many=True)
        return serializer.data

    def get_utility_software(
            self, obj: WorkplaceType) -> List[OrderedDict[str, Any]]:
        location_serializer = UtilitySoftwareSerializer(
            obj.location.default_utility_software, many=True)
        workplace_serializer = UtilitySoftwareSerializer(obj.utility_software,
                                                         many=True)
        joined_data = list(location_serializer.data) + list(
            workplace_serializer.data)
        data = []
        for d in joined_data:
            if d not in data:
                data.append(d)
        return data

    def get_sites(self, obj: WorkplaceType) -> List[OrderedDict[str, Any]]:
        location_serializer = SiteSerializer(obj.location.default_sites,
                                             many=True)
        workplace_serializer = SiteSerializer(obj.sites, many=True)
        joined_data = list(location_serializer.data) + list(
            workplace_serializer.data)
        data = []
        for d in joined_data:
            if d not in data:
                data.append(d)
        return data

    def get_password(self, obj: WorkplaceType) -> Union[str, Any]:
        password = obj.location.password
        return password


class LocationSerializer(serializers.ModelSerializer[Location]):
    workplace_types = SerializerMethodField()

    class Meta:
        model = Location
        fields = ('id', 'name', 'description', 'workplace_types')

    def get_workplace_types(self, location: Location) -> OrderedDict[str, Any]:
        workplace_types = WorkplaceType.objects.filter(location=location,
                                                       is_active=True)
        serializer = WorkplaceTypeSerializer(workplace_types, many=True)
        return serializer.data


class ExclusiveProgramSerializer(serializers.ModelSerializer[ExclusiveProgram]
                                 ):
    icon = SerializerMethodField()

    class Meta:
        model = ExclusiveProgram
        fields = ('id', 'name', 'label', 'description', 'executable_path',
                  'fallback_path', 'parameters', 'icon', 'order')

    def get_icon(self, obj: ExclusiveProgram) -> Union[str, Any]:
        return obj.icon.url if obj.icon else None


class WorkplaceSerializer(serializers.ModelSerializer[Workplace]):
    workplace_type = SerializerMethodField()
    exclusive_program = SerializerMethodField()
    sites = SerializerMethodField()
    organizational_unit = SerializerMethodField()

    class Meta:
        model = Workplace
        fields = ('hostname', 'description', 'workplace_type',
                  'workplace_system', 'workplace_name', 'exclusive_program',
                  'sites', 'is_active', 'organizational_unit')

    def get_workplace_type(self,
                           workplace: Workplace) -> OrderedDict[str, Any]:
        serializer = WorkplaceTypeFullInfoSerializer(workplace.workplace_type,
                                                     many=False)
        return serializer.data

    def get_sites(self, obj: Workplace) -> OrderedDict[str, Any]:
        serializer = SiteSerializer(obj.sites, many=True)
        return serializer.data

    def get_exclusive_program(self, obj: Workplace) -> Any:
        if obj.exclusive_program:
            serializer = ExclusiveProgramSerializer(obj.exclusive_program,
                                                    many=False)
            return serializer.data
        else:
            return None

    def get_organizational_unit(self, obj: Workplace) -> Any:
        ou = obj.organizationalunit_set.first()    # type: ignore
        if ou:
            return ou.pk
        return None