from pprint import pprint
from django.conf import settings

from transfer import models as transfer_models
from transfer.serializers import product as product_serializers
from transfer.serializers.partner import PartnerSerializer

from product.models import ProductType, ProductSubType


def transfer_product_types():
    product_types = ['wine', 'souvenir']
    for product_type in product_types:
        ProductType.objects.get_or_create(**{
            'name': {settings.FALLBACK_LOCALE: product_type},
            'index_name': product_type
        })


def transfer_product_subtype():
    error_counter = 0
    create_counter = 0

    product_subtypes = {
        'plate': {
            'product_type_index_name': 'souvenir',
            'name': 'plate',
            'index_name': 'plate',
        }
    }
    for product_subtype in product_subtypes.values():
        product_type_qs = ProductType.objects.filter(
            index_name=product_subtype.get('product_type_index_name'))
        if product_type_qs:
            product_type = product_type_qs.first()
            subtype, status = ProductSubType.objects.get_or_create(**{
                'name': {settings.FALLBACK_LOCALE: product_subtype.get('name')},
                'index_name': product_subtype.get('index_name'),
                'product_type': product_type
            })
            create_counter += 1 if status else 0
        else:
            error_counter += 1
    print(f'Errors occurred: {error_counter}\nCreated: {create_counter}')


def transfer_partner():
    queryset = transfer_models.EstablishmentBacklinks.objects.filter(type="Partner")

    serialized_data = PartnerSerializer(data=list(queryset.values()), many=True)
    if serialized_data.is_valid():
        serialized_data.save()
    else:
        pprint(f"News serializer errors: {serialized_data.errors}")


def transfer_wine_color():
    queryset = transfer_models.WineColor.objects.all()
    serialized_data = product_serializers.WineColorSerializer(
        data=list(queryset.values()),
        many=True)
    if serialized_data.is_valid():
        serialized_data.save()
    else:
        pprint(f"transfer_wine_color errors: {serialized_data.errors}")


def transfer_wine_sugar_content():
    queryset = transfer_models.WineType.objects.all()
    serialized_data = product_serializers.WineTypeSerializer(
        data=list(queryset.values()),
        many=True)
    if serialized_data.is_valid():
        serialized_data.save()
    else:
        pprint(f"transfer_wine_sugar_content errors: {serialized_data.errors}")


def transfer_wine_bottles_produced():
    raw_queryset = transfer_models.Products.objects.raw(
        """
        SELECT
           DISTINCT bottles_produced,
           1 as id
        FROM products
        WHERE bottles_produced IS NOT NULL 
        AND bottles_produced !='';
        """
    )
    queryset = [vars(query) for query in raw_queryset]
    serialized_data = product_serializers.WineBottlesProducedSerializer(
      data=queryset,
      many=True)
    if serialized_data.is_valid():
        serialized_data.save()
    else:
        pprint(f"transfer_wine_bottles_produced errors: {serialized_data.errors}")


def transfer_wine_classification_type():
    raw_queryset = transfer_models.ProductClassification.objects.raw(
        """
        SELECT
           DISTINCT name,
           1 as id
        FROM wine_classifications;
        """
    )
    queryset = [vars(query) for query in raw_queryset]
    serialized_data = product_serializers.WineClassificationTypeSerializer(
      data=queryset,
      many=True)
    if serialized_data.is_valid():
        serialized_data.save()
    else:
        pprint(f"transfer_classification errors: {serialized_data.errors}")


def transfer_wine_standard():
    queryset = transfer_models.ProductClassification.objects.filter(parent_id__isnull=True) \
                                                         .exclude(type='Classification')
    serialized_data = product_serializers.ProductStandardSerializer(
      data=list(queryset.values()),
      many=True)
    if serialized_data.is_valid():
        serialized_data.save()
    else:
        pprint(f"transfer_wine_standard errors: {serialized_data.errors}")


def transfer_wine_classifications():
    queryset = transfer_models.ProductClassification.objects.filter(type='Classification')
    serialized_data = product_serializers.ProductClassificationSerializer(
      data=list(queryset.values()),
      many=True)
    if serialized_data.is_valid():
        serialized_data.save()
    else:
        pprint(f"transfer_wine_classifications errors: {serialized_data.errors}")


def transfer_product_brand():
    raw_queryset = transfer_models.Products.objects.raw(
        """
        SELECT
           DISTINCT brand,
           1 as id
        FROM products
        WHERE brand IS NOT NULL 
        AND brand !='';
        """
    )
    queryset = [vars(query) for query in raw_queryset]
    serialized_data = product_serializers.ProductBrandSerializer(
      data=queryset,
      many=True)
    if serialized_data.is_valid():
        serialized_data.save()
    else:
        pprint(f"transfer_product_brand errors: {serialized_data.errors}")


def transfer_product():
    queryset = transfer_models.Products.objects.all()
    serialized_data = product_serializers.ProductSerializer(
      data=list(queryset.values()),
      many=True)
    if serialized_data.is_valid():
        serialized_data.save()
    else:
        pprint(f"transfer_product errors: {serialized_data.errors}")


data_types = {
    "partner": [transfer_partner],
    "product_type": [
        transfer_product_types,
        transfer_product_subtype,
    ],
    "wine_characteristics": [
        transfer_wine_sugar_content,
        transfer_wine_color,
        transfer_wine_bottles_produced,
        transfer_wine_classification_type,
        transfer_wine_standard,
        transfer_wine_classifications,
        ],
    "product": [
        transfer_product_brand,
        transfer_product
    ],
}