import os
import csv
import json
import copy
import logging
import pandas as pd
from pathlib import Path
from jsonschema import validate
from smtplib import SMTPException

from django.conf import settings
from django.utils.translation import gettext_lazy as _
from django.views.generic.base import TemplateView
from django.views.generic.edit import UpdateView, CreateView, DeleteView
from django.shortcuts import get_object_or_404, redirect
from django.urls import reverse_lazy
from django.http import HttpResponse
from django.contrib import messages
from apiregiter import iota
from idhub_auth.models import User
from idhub.mixins import AdminView
from idhub.email.views import NotifyActivateUserByEmail
from idhub.models import (
    DID,
    File_datas,
    Membership,
    Rol,
    Service,
    Schemas,
    UserRol,
    VerifiableCredential,
)


class AdminDashboardView(AdminView, TemplateView):
    template_name = "idhub/admin/dashboard.html"
    title = _('Dashboard')
    subtitle = _('Success')
    icon = 'bi bi-bell'
    section = "Home"

class People(AdminView):
    title = _("People Management")
    section = "People"


class AccessControl(AdminView, TemplateView):
    title = _("Access Control Management")
    section = "AccessControl"


class Credentials(AdminView, TemplateView):
    title = _("Credentials Management")
    section = "Credentials"


class SchemasMix(AdminView, TemplateView):
    title = _("Templates Management")
    section = "Templates"


class ImportExport(AdminView, TemplateView):
    title = _("Massive Data Management")
    section = "ImportExport"


class AdminPeopleListView(People, TemplateView):
    template_name = "idhub/admin/people.html"
    subtitle = _('People list')
    icon = 'bi bi-person'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context.update({
            'users': User.objects.filter(),
        })
        return context


class AdminPeopleView(People, TemplateView):
    template_name = "idhub/admin/user.html"
    subtitle = _('User Profile')
    icon = 'bi bi-person'
    model = User

    def get(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.object = get_object_or_404(self.model, pk=self.pk)
        return super().get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context.update({
            'object': self.object,
        })
        return context


class AdminPeopleActivateView(AdminPeopleView):

    def get(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.object = get_object_or_404(self.model, pk=self.pk)

        if self.object == self.request.user:
            messages.error(self.request, _('Is not possible deactivate your account!'))
            return redirect('idhub:admin_people', self.object.id)

        if self.object.is_active:
            self.object.is_active = False
        else:
            self.object.is_active = True
        self.object.save()

        return redirect('idhub:admin_people', self.object.id)
            

class AdminPeopleDeleteView(AdminPeopleView):

    def get(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.object = get_object_or_404(self.model, pk=self.pk)

        if self.object != self.request.user:
            self.object.delete()
        else:
            messages.error(self.request, _('Is not possible delete your account!'))

        return redirect('idhub:admin_people_list')
            
class AdminPeopleEditView(AdminPeopleView, UpdateView):
    template_name = "idhub/admin/user_edit.html"
    fields = ('first_name', 'last_name', 'email')
    success_url = reverse_lazy('idhub:admin_people_list')


class AdminPeopleRegisterView(NotifyActivateUserByEmail, People, CreateView):
    template_name = "idhub/admin/people_register.html"
    subtitle = _('People Register')
    icon = 'bi bi-person'
    model = User
    fields = ('first_name', 'last_name', 'email')
    success_url = reverse_lazy('idhub:admin_people_list')

    def get_success_url(self):
        self.success_url = reverse_lazy(
            'idhub:admin_people_membership_new',
            kwargs={"pk": self.object.id}
        )
        return self.success_url

    def form_valid(self, form):
        user = form.save()
        messages.success(self.request, _('The account is created successfully'))
        if user.is_active:
            try:
                self.send_email(user)
            except SMTPException as e:
                messages.error(self.request, e)
        return super().form_valid(form)


class AdminPeopleMembershipRegisterView(People, CreateView):
    template_name = "idhub/admin/people_membership_register.html"
    subtitle = _('People add membership')
    icon = 'bi bi-person'
    model = Membership
    fields = ('type', 'start_date', 'end_date')
    success_url = reverse_lazy('idhub:admin_people_list')

    def get(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.user = get_object_or_404(User, pk=self.pk)
        return super().get(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.user = get_object_or_404(User, pk=self.pk)
        return super().post(request, *args, **kwargs)

    def get_form(self):
        form = super().get_form()
        form.fields['start_date'].widget.input_type = 'date'
        form.fields['end_date'].widget.input_type = 'date'
        return form

    def get_form_kwargs(self):
        self.object = self.model(user=self.user)
        kwargs = super().get_form_kwargs()
        return kwargs

    def get_success_url(self):
        self.success_url = reverse_lazy(
            'idhub:admin_people_rol_new',
            kwargs={"pk": self.user.id}
        )
        return self.success_url


class AdminPeopleMembershipEditView(People, CreateView):
    template_name = "idhub/admin/people_membership_register.html"
    subtitle = _('People add membership')
    icon = 'bi bi-person'
    model = Membership
    fields = ('type', 'start_date', 'end_date')
    success_url = reverse_lazy('idhub:admin_people_list')

    def get_form(self):
        form = super().get_form()
        form.fields['start_date'].widget.input_type = 'date'
        form.fields['end_date'].widget.input_type = 'date'
        return form

    def get_form_kwargs(self):
        pk = self.kwargs.get('pk')
        if pk:
            self.object = get_object_or_404(self.model, pk=pk)
        kwargs = super().get_form_kwargs()
        return kwargs


class AdminPeopleMembershipDeleteView(AdminPeopleView):
    model = Membership

    def get(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.object = get_object_or_404(self.model, pk=self.pk)

        if self.object != self.request.user:
            user = self.object.user
            self.object.delete()
        else:
            messages.error(self.request, _('Is not possible delete your account!'))

        return redirect('idhub:admin_people_edit', user.id)

        
class AdminPeopleRolRegisterView(People, CreateView):
    template_name = "idhub/admin/people_rol_register.html"
    subtitle = _('Add Rol to User')
    icon = 'bi bi-person'
    model = UserRol
    fields = ('service',)

    def get(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.user = get_object_or_404(User, pk=self.pk)
        return super().get(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.user = get_object_or_404(User, pk=self.pk)
        return super().post(request, *args, **kwargs)

    def get_form_kwargs(self):
        self.object = self.model(user=self.user)
        kwargs = super().get_form_kwargs()
        return kwargs

    def get_success_url(self):
        self.success_url = reverse_lazy(
            'idhub:admin_people_edit',
            kwargs={"pk": self.user.id}
        )
        return self.success_url


class AdminPeopleRolEditView(People, CreateView):
    template_name = "idhub/admin/people_rol_register.html"
    subtitle = _('Edit Rol to User')
    icon = 'bi bi-person'
    model = UserRol
    fields = ('service',)

    def get_form_kwargs(self):
        pk = self.kwargs.get('pk')
        if pk:
            self.object = get_object_or_404(self.model, pk=pk)
        kwargs = super().get_form_kwargs()
        return kwargs

    def get_success_url(self):
        self.success_url = reverse_lazy(
            'idhub:admin_people_edit',
            kwargs={"pk": self.object.user.id}
        )
        return self.success_url


class AdminPeopleRolDeleteView(AdminPeopleView):
    model = UserRol

    def get(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.object = get_object_or_404(self.model, pk=self.pk)
        user = self.object.user

        self.object.delete()

        return redirect('idhub:admin_people_edit', user.id)


class AdminRolesView(AccessControl):
    template_name = "idhub/admin/roles.html"
    subtitle = _('Roles Management')
    icon = ''

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context.update({
            'roles': Rol.objects,
        })
        return context

class AdminRolRegisterView(AccessControl, CreateView):
    template_name = "idhub/admin/rol_register.html"
    subtitle = _('Add Rol')
    icon = ''
    model = Rol
    fields = ('name',)
    success_url = reverse_lazy('idhub:admin_roles')
    object = None

        
class AdminRolEditView(AccessControl, CreateView):
    template_name = "idhub/admin/rol_register.html"
    subtitle = _('Edit Rol')
    icon = ''
    model = Rol
    fields = ('name',)
    success_url = reverse_lazy('idhub:admin_roles')

    def get_form_kwargs(self):
        pk = self.kwargs.get('pk')
        if pk:
            self.object = get_object_or_404(self.model, pk=pk)
        kwargs = super().get_form_kwargs()
        return kwargs


class AdminRolDeleteView(AccessControl):
    model = Rol

    def get(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.object = get_object_or_404(self.model, pk=self.pk)

        self.object.delete()
        return redirect('idhub:admin_roles')


class AdminServicesView(AccessControl):
    template_name = "idhub/admin/services.html"
    subtitle = _('Service Management')
    icon = ''

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context.update({
            'services': Service.objects,
        })
        return context

class AdminServiceRegisterView(AccessControl, CreateView):
    template_name = "idhub/admin/service_register.html"
    subtitle = _('Add Service')
    icon = ''
    model = Service
    fields = ('domain', 'description', 'rol')
    success_url = reverse_lazy('idhub:admin_services')
    object = None

        
class AdminServiceEditView(AccessControl, CreateView):
    template_name = "idhub/admin/service_register.html"
    subtitle = _('Edit Service')
    icon = ''
    model = Service
    fields = ('domain', 'description', 'rol')
    success_url = reverse_lazy('idhub:admin_services')

    def get_form_kwargs(self):
        pk = self.kwargs.get('pk')
        if pk:
            self.object = get_object_or_404(self.model, pk=pk)
        kwargs = super().get_form_kwargs()
        return kwargs


class AdminServiceDeleteView(AccessControl):
    model = Service

    def get(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.object = get_object_or_404(self.model, pk=self.pk)

        self.object.delete()
        return redirect('idhub:admin_services')


class AdminCredentialsView(Credentials):
    template_name = "idhub/admin/credentials.html"
    subtitle = _('Credentials list')
    icon = ''

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context.update({
            'credentials': VerifiableCredential.objects,
        })
        return context


class AdminIssueCredentialsView(Credentials):
    template_name = "idhub/admin/issue_credentials.html"
    subtitle = _('Issuance of Credentials')
    icon = ''


class AdminRevokeCredentialsView(Credentials):
    template_name = "idhub/admin/revoke_credentials.html"
    subtitle = _('Revoke Credentials')
    icon = ''


class AdminDidsView(Credentials):
    template_name = "idhub/admin/dids.html"
    subtitle = _('Organization Identities (DID)')
    icon = 'bi bi-patch-check-fill'
    wallet = True

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context.update({
            'dids': DID.objects,
        })
        return context

class AdminDidRegisterView(Credentials, CreateView):
    template_name = "idhub/admin/did_register.html"
    subtitle = _('Add a new Organization Identities (DID)')
    icon = 'bi bi-patch-check-fill'
    wallet = True
    model = DID
    fields = ('did', 'label')
    success_url = reverse_lazy('idhub:admin_dids')
    object = None

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['initial'] = {
            'did': iota.issue_did()
        }
        return kwargs

    def get_form(self):
        form = super().get_form()
        form.fields['did'].required = False
        form.fields['did'].disabled = True
        return form

    def form_valid(self, form):
        user = form.save()
        messages.success(self.request, _('DID created successfully'))
        return super().form_valid(form)


class AdminDidEditView(Credentials, UpdateView):
    template_name = "idhub/admin/did_register.html"
    subtitle = _('Organization Identities (DID)')
    icon = 'bi bi-patch-check-fill'
    wallet = True
    model = DID
    fields = ('did', 'label')
    success_url = reverse_lazy('idhub:admin_dids')

    def get(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.object = get_object_or_404(self.model, pk=self.pk)
        return super().get(request, *args, **kwargs)

    def get_form(self):
        form = super().get_form()
        form.fields['did'].required = False
        form.fields['did'].disabled = True
        return form

    def form_valid(self, form):
        user = form.save()
        messages.success(self.request, _('DID created successfully'))
        return super().form_valid(form)


class AdminDidDeleteView(Credentials, DeleteView):
    subtitle = _('Organization Identities (DID)')
    icon = 'bi bi-patch-check-fill'
    wallet = True
    model = DID
    success_url = reverse_lazy('idhub:admin_dids')

    def get(self, request, *args, **kwargs):
        # import pdb; pdb.set_trace()
        self.pk = kwargs['pk']
        self.object = get_object_or_404(self.model, pk=self.pk)
        self.object.delete()

        return redirect(self.success_url)


class AdminWalletCredentialsView(Credentials):
    template_name = "idhub/admin/wallet_credentials.html"
    subtitle = _('Credentials')
    icon = 'bi bi-patch-check-fill'
    wallet = True


class AdminWalletConfigIssuesView(Credentials):
    template_name = "idhub/admin/wallet_issues.html"
    subtitle = _('Configure Issues')
    icon = 'bi bi-patch-check-fill'
    wallet = True


class AdminSchemasView(SchemasMix):
    template_name = "idhub/admin/schemas.html"
    subtitle = _('Template List')
    icon = ''

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context.update({
            'schemas': Schemas.objects,
        })
        return context

        
class AdminSchemasDeleteView(SchemasMix):

    def get(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.object = get_object_or_404(Schemas, pk=self.pk)
        self.object.delete()

        return redirect('idhub:admin_schemas')


class AdminSchemasDownloadView(SchemasMix):

    def get(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.object = get_object_or_404(Schemas, pk=self.pk)

        response = HttpResponse(self.object.data, content_type="application/json")
        response['Content-Disposition'] = 'inline; filename={}'.format(self.object.file_schema)
        return response


class AdminSchemasNewView(SchemasMix):
    template_name = "idhub/admin/schemas_new.html"
    subtitle = _('Upload Template')
    icon = ''
    success_url = reverse_lazy('idhub:admin_schemas')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context.update({
            'form': SchemaForm(),
        })
        return context

    def post(self, request, *args, **kwargs):
        form = SchemaForm(request.POST, request.FILES)
        if form.is_valid():
            schema = self.handle_uploaded_file()
            if not schema:
                messages.error(request, _("There are some errors in the file"))
                return super().get(request, *args, **kwargs)
            return redirect(self.success_url)
        else:
            return super().get(request, *args, **kwargs)

        return super().post(request, *args, **kwargs)

    def handle_uploaded_file(self):
        f = self.request.FILES.get('file_template')
        if not f:
            return
        file_name = f.name
        if Schemas.objects.filter(file_schema=file_name).exists():
            messages.error(self.request, _("This template already exists!"))
            return
        try:
            data = f.read().decode('utf-8')
            json.loads(data)
        except Exception:
            messages.error(self.request, _('This is not a schema valid!'))
            return
        schema = Schemas.objects.create(file_schema=file_name, data=data)
        schema.save()
        return schema


class AdminSchemasImportView(SchemasMix):
    template_name = "idhub/admin/schemas_import.html"
    subtitle = _('Import Template')
    icon = ''

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context.update({
            'schemas': self.get_schemas(),
        })
        return context

    def get_schemas(self):
        schemas_files = os.listdir(settings.SCHEMAS_DIR)
        schemas = [x for x  in schemas_files 
            if not Schemas.objects.filter(file_schema=x).exists()]
        return schemas

        
class AdminSchemasImportAddView(SchemasMix):

    def get(self, request, *args, **kwargs):
        file_name = kwargs['file_schema']
        schemas_files = os.listdir(settings.SCHEMAS_DIR)
        if not file_name in schemas_files:
            messages.error(self.request, f"The schema {file_name} not exist!")
            return redirect('idhub:admin_schemas_import')

        schema = self.create_schema(file_name)
        if schema:
            messages.success(self.request, _("The schema add successfully!"))
        return redirect('idhub:admin_schemas_import')

    def create_schema(self, file_name):
        data = self.open_file(file_name)
        try:
            json.loads(data)
        except Exception:
            messages.error(self.request, _('This is not a schema valid!'))
            return
        schema = Schemas.objects.create(file_schema=file_name, data=data)
        schema.save()
        return schema

    def open_file(self, file_name):
        data = ''
        filename = Path(settings.SCHEMAS_DIR).joinpath(file_name)
        with filename.open() as schema_file:
            data = schema_file.read()

        return data


class AdminImportView(ImportExport):
    template_name = "idhub/admin/import.html"
    subtitle = _('Import')
    icon = ''

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context.update({
            'dates': File_datas.objects,
        })
        return context


class AdminImportStep2View(ImportExport):
    template_name = "idhub/admin/import_step2.html"
    subtitle = _('Import')
    icon = ''

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context.update({
            'schemas': Schemas.objects,
        })
        return context


class AdminImportStep3View(ImportExport):
    template_name = "idhub/admin/import_step3.html"
    subtitle = _('Import')
    icon = ''
    success_url = reverse_lazy('idhub:admin_import')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context.update({
            'form': ImportForm(),
        })
        return context

    def post(self, request, *args, **kwargs):
        self.pk = kwargs['pk']
        self.schema = get_object_or_404(Schemas, pk=self.pk)
        form = ImportForm(request.POST, request.FILES)
        if form.is_valid():
            result = self.handle_uploaded_file()
            if not result:
                messages.error(request, _("There are some errors in the file"))
                return super().get(request, *args, **kwargs)
            return redirect(self.success_url)
        else:
            return super().get(request, *args, **kwargs)

        return super().post(request, *args, **kwargs)

    def handle_uploaded_file(self):
        f = self.request.FILES.get('file_import')
        if not f:
            messages.error(self.request, _("There aren't file"))
            return

        file_name = f.name
        if File_datas.objects.filter(file_name=file_name, success=True).exists():
            messages.error(self.request, _("This file already exists!"))
            return

        self.json_schema = json.loads(self.schema.data)
        df = pd.read_csv (f, delimiter="\t", quotechar='"', quoting=csv.QUOTE_ALL)
        data_pd = df.fillna('').to_dict()
        rows = {}

        if not data_pd:
            File_datas.objects.create(file_name=file_name, success=False)
            return

        for n in range(df.last_valid_index()+1):
            row = {}
            for k in data_pd.keys():
                row[k] = data_pd[k][n]

            user = self.validate(n, row)
            if not user:
                File_datas.objects.create(file_name=file_name, success=False)
                return

            rows[user] = row

        File_datas.objects.create(file_name=file_name)
        for k, v in rows.items():
            self.create_credential(k, v)

        return True

    def validate(self, line, row):
        try:
            validate(instance=row, schema=self.json_schema)
        except Exception as e:
            messages.error(self.request, "line {}: {}".format(line+1, e))
            return

        user = User.objects.filter(email=row.get('email'))
        if not user:
            txt = _('The user not exist!')
            messages.error(self.request, "line {}: {}".format(line+1, txt))
            return

        return user.first()

    def create_credential(self, user, row):
        d = copy.copy(self.json_schema)
        d['instance'] = row
        return VerifiableCredential.objects.create(
            verified=False,
            user=user,
            data=json.dumps(d)
        )