# -*- coding: utf-8 -*-
from __future__ import unicode_literals

import itertools
import unicodecsv as csv

from optparse import make_option

from django.core.exceptions import ObjectDoesNotExist
from django.core.management.base import BaseCommand

from redmag.acuerdo.models import Nivel, Grado
from redmag.nuevomodelo.models import CampoFormativoNME


class Command(BaseCommand):
    def __init__(self, *args, **kwargs):
        self.campo_formativo_creados = 0
        self.campo_formativo_existentes = 0
        self.asignatura_creados = 0
        self.asignatura_existentes = 0
        self.tema_creados = 0
        self.tema_existentes = 0
        self.objetivo_creados = 0
        self.objetivo_existentes = 0
        self.practicasocial_creados = 0
        self.practicasocial_existentes = 0
        self.aprendizaje_creados = 0
        self.aprendizaje_existentes = 0
        super(Command, self).__init__(*args, **kwargs)

    args = '<csv_path_espaniol>'
    help = 'Importa Aprendizajes esperados desde un archivo CSV'

    option_list = BaseCommand.option_list + (
        make_option(
            '--es-ingles',
            action='store_true',
            dest='es_ingles',
            help='Indica si el archivo de cargar es para Inglés'
        ),
        make_option(
            '--delimiter',
            action='store',
            dest='delimiter',
            default=',',
            help='Delimitador de archivo CSV'
        ),
    )

    def obtener_registros_csv(self, csv_path, delimiter=','):
        with open(csv_path, 'r') as csv_file:
            registros = csv.DictReader(csv_file, delimiter=delimiter)
            registros_list = list(registros)
        return registros_list

    def obtener_campos_aprendizaje(self, campos):
        return sorted(
            filter(
                lambda nombre_campo: nombre_campo.lower().startswith('aprendizaje'),  # noqa
                campos
            )
        )

    def asignaturas_base(self, _dict):
        return (
            _dict['Nivel escolar'],
            _dict['Grado escolar'],
            _dict['Campo Formativo'],
            _dict['Asignatura'],
            _dict['Ámbito'],  # Tema
            _dict['Prácticas sociales del Lenguage'],  # Objetivo
        )

    def asignaturas_ingles(self, _dict):
        return (
            _dict['Nivel escolar'],
            _dict['Grado escolar'],
            _dict['Campo Formativo'],
            _dict['Asignatura'],
            _dict['Ambientes Sociales de Aprendizaje'],  # Tema
            _dict['Actividad Comunicativa'],  # Objetivo
            _dict['Práctica Social del lenguaje'],  # Practica social
        )

    def handle(self, *args, **options):
        csv_path_espaniol = args[0]

        csv_registros = self.obtener_registros_csv(
            csv_path_espaniol,
            delimiter=str(options['delimiter'])
        )

        es_ingles = options['es_ingles']
        _sorted_groupby = (
            es_ingles and self.asignaturas_ingles
        ) or self.asignaturas_base

        csv_registros_sorted = sorted(
            csv_registros,
            key=_sorted_groupby
        )
        csv_registros_groupby = itertools.groupby(
            csv_registros_sorted,
            key=_sorted_groupby
        )

        for grouper, aprendizajes in csv_registros_groupby:
            # Asignaturas Inglés
            if es_ingles:
                (
                    _nivel,
                    _grado,
                    _campo_formativo,
                    _asignatura,
                    _ambiente,
                    _actividad,
                    _practica_social,
                ) = grouper

                nivel = Nivel.objects.get(nombre=_nivel)
                grado = Grado.objects.get(
                    ciclo__nivel=nivel,
                    texto__istartswith=_grado
                )
                campo_formativo = self.obtener_campo_formativo(
                    _campo_formativo
                )
                asignatura = self.obtener_asignatura(
                    _asignatura, grado, campo_formativo
                )
                tema = self.obtener_tema(
                    _ambiente, asignatura
                )
                objetivo = self.obtener_objetivo(
                    _actividad, tema
                )
                practicasocial = self.obtener_practicasocial(
                    _practica_social, objetivo
                )

                for aprendizaje in list(aprendizajes):
                    campos_aprendizaje = self.obtener_campos_aprendizaje(
                        aprendizaje.keys()
                    )
                    for campo_aprendizaje in campos_aprendizaje:
                        nombre = aprendizaje[campo_aprendizaje].strip()
                        if nombre:
                            self.stdout.write(
                                "procesando aprendizaje: ({nivel} - {grado} - {asignatura} {tema} - {objetivo}): {aprendizaje}".format(  # noqa
                                    nivel=nivel,
                                    grado=grado,
                                    asignatura=asignatura,
                                    tema=tema,
                                    objetivo=objetivo,
                                    aprendizaje=campo_aprendizaje
                                )
                            )
                            self.obtener_aprendizaje_desde_practicasocial(
                                nombre, practicasocial
                            )
            # Asignaturas base
            else:
                (
                    _nivel,
                    _grado,
                    _campo_formativo,
                    _asignatura,
                    _ambito, _practicas_sociales,
                ) = grouper

                nivel = Nivel.objects.get(nombre=_nivel)
                grado = Grado.objects.get(
                    ciclo__nivel=nivel,
                    texto__istartswith=_grado
                )
                campo_formativo = self.obtener_campo_formativo(
                    _campo_formativo
                )
                asignatura = self.obtener_asignatura(
                    _asignatura, grado, campo_formativo
                )
                tema = self.obtener_tema(
                    _ambito, asignatura
                )
                objetivo = self.obtener_objetivo(
                    _practicas_sociales, tema
                )

                for aprendizaje in list(aprendizajes):
                    campos_aprendizaje = self.obtener_campos_aprendizaje(
                        aprendizaje.keys()
                    )
                    for campo_aprendizaje in campos_aprendizaje:
                        nombre = aprendizaje[campo_aprendizaje].strip()
                        if nombre:
                            self.stdout.write(
                                "procesando aprendizaje: ({nivel} - {grado} - {asignatura} {tema} - {objetivo}): {aprendizaje}".format(  # noqa
                                    nivel=nivel,
                                    grado=grado,
                                    asignatura=asignatura,
                                    tema=tema,
                                    objetivo=objetivo,
                                    aprendizaje=campo_aprendizaje
                                )
                            )
                            self.obtener_aprendizaje_desde_objetivo(
                                nombre, objetivo
                            )

        self.stdout.write("campo_formativo_creados: {}\n".format(self.campo_formativo_creados))
        self.stdout.write("campo_formativo_existentes: {}\n".format(self.campo_formativo_existentes))
        self.stdout.write("asignatura_creados: {}\n".format(self.asignatura_creados))
        self.stdout.write("asignatura_existentes: {}\n".format(self.asignatura_existentes))
        self.stdout.write("tema_creados: {}\n".format(self.tema_creados))
        self.stdout.write("tema_existentes: {}\n".format(self.tema_existentes))
        self.stdout.write("objetivo_creados: {}\n".format(self.objetivo_creados))
        self.stdout.write("objetivo_existentes: {}\n".format(self.objetivo_existentes))
        self.stdout.write("practicasocial_creados: {}\n".format(self.practicasocial_creados))
        self.stdout.write("practicasocial_existentes: {}\n".format(self.practicasocial_existentes))
        self.stdout.write("aprendizaje_creados: {}\n".format(self.aprendizaje_creados))
        self.stdout.write("aprendizaje_existentes: {}\n".format(self.aprendizaje_existentes))

    def obtener_campo_formativo(self, nombre):
        """
        Obtiene y retorna un campo formativo.

        Si no existe lo crea.
        """

        try:
            item = CampoFormativoNME.objects.get(
                nombre__iexact=nombre
            )
            item.validado = True
            item.save()
            self.campo_formativo_existentes += 1
        except ObjectDoesNotExist:
            item = CampoFormativoNME.objects.create(
                nombre=nombre,
                validado=True
            )
            self.campo_formativo_creados += 1

        return item


    def obtener_asignatura(self, nombre, grado, campo_formativo):
        """
        Obtiene y retorna un objeto AsignaturaNME tomando como referencia
        un grado y un nombre de asignatura leído desde el documento.

        Si la asignatura no existe es creada.
        """

        try:
            item = grado.asignaturanme.get(
                nombre__iexact=nombre,
                campo_formativo=campo_formativo
            )
            item.validado = True
            item.save()
            self.asignatura_existentes += 1
        except ObjectDoesNotExist:
            item = grado.asignaturanme.create(
                nombre=nombre,
                campo_formativo=campo_formativo,
                validado=True
            )
            self.asignatura_creados += 1

        return item

    def obtener_tema(self, nombre, asignatura):
        """
        Obtiene y retorna un objeto TemaNME tomando como referencia
        un asignatura y un nombre de tema leído desde el documento.

        Si el tema no existe es creado.
        """

        try:
            item = asignatura.temanme.get(
                nombre__iexact=nombre
            )
            item.validado = True
            item.save()
            self.tema_existentes += 1
        except ObjectDoesNotExist:
            item = asignatura.temanme.create(
                nombre=nombre,
                validado=True
            )
            self.tema_creados += 1

        return item

    def obtener_objetivo(self, nombre, tema):
        """
        Obtiene y retorna un objeto ObjetivoNME tomando como referencia
        un nombre de objetivo y un tema leído desde el documento.

        Si el objetivo no existe es creado.
        """

        try:
            item = tema.objetivonme.get(
                nombre__iexact=nombre
            )
            item.validado = True
            item.save()
            self.objetivo_existentes += 1
        except ObjectDoesNotExist:
            item = tema.objetivonme.create(
                nombre=nombre,
                validado=True
            )
            self.objetivo_creados += 1

        return item

    def obtener_practicasocial(self, name, objetivo):
        """
        Obtiene y retorna un objeto PracticaSocialNME tomando como
        referencia un objetivo y un nombre de practicasocial
        leído desde el documento.

        Si la practicasocial no existe es creada.
        """

        try:
            item = objetivo.practicasocialnme.get(
                nombre__iexact=name
            )
            item.validado = True
            item.save()
            self.practicasocial_existentes += 1
        except ObjectDoesNotExist:
            item = objetivo.practicasocialnme.create(
                nombre=name,
                validado=True
            )
            self.practicasocial_creados += 1

        return item

    def obtener_aprendizaje_desde_objetivo(self, nombre, objetivo):
        """
        Obtiene y retorna un objeto aprendizajeesperado tomando como
        referencia un objetivo, con el nombre del
        aprendizaje esperado, leído del documento.

        Si el aprendizaje esperado no existe es creado.
        """

        try:
            item = objetivo.aprendizajeesperadonme.get(
                nombre__iexact=nombre
            )
            item.validado = True
            item.save()
            self.aprendizaje_existentes += 1
        except ObjectDoesNotExist:
            item = objetivo.aprendizajeesperadonme.create(
                nombre=nombre,
                is_ingles=False,
                validado=True
            )
            self.aprendizaje_creados += 1

        return item

    def obtener_aprendizaje_desde_practicasocial(self, name,  practicasocial):
        """
        Obtiene y retorna un objeto aprendizajeesperado tomando como
        referencia una practica social, con el nombre del
        aprendizaje esperado, leído del documento.

        Si el aprendizaje esperado no existe es creado.
        """

        try:
            item = practicasocial.aprendizajeesperadonme.get(
                nombre__iexact=name
            )
            item.validado = True
            item.save()
            self.aprendizaje_existentes += 1
        except ObjectDoesNotExist:
            item = practicasocial.aprendizajeesperadonme.create(
                nombre=name,
                is_ingles=True,
                validado=True
            )
            self.aprendizaje_creados += 1

        return item