import json
import pydash as _; _.map = _.map_; _.filter = _.filter_
import re

from django.conf import settings
from django.contrib import messages
from django.contrib.auth.mixins import PermissionRequiredMixin, LoginRequiredMixin
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.core.urlresolvers import reverse, reverse_lazy
from django.core.files.base import ContentFile
from django.db.models import Q
from django.http import HttpResponseForbidden, HttpResponseRedirect, HttpResponse, Http404
from django.shortcuts import render, get_object_or_404, redirect
from django.views.generic import ListView, DetailView, CreateView, View, UpdateView, TemplateView, FormView
from django.views.generic.base import ContextMixin
from pprint import pprint, pformat

from .mixins import LastAccessMixin
from .models import Project, ProjectFile, Portfolio, Candidate, Answer, Realty, Order, PortfolioPhoto
from archilance.mixins import BaseMixin
from users.models import User
from work_sell.models import Picture

from .forms import (
    ContractorProjectAnswerForm,
    CustomerProjectDeleteForm,
    CustomerProjectEditForm,
    CustomerProjectEditForm,
    CustomerProjectRestoreForm,
    CustomerProjectTrashForm,
    PortfolioForm,
    ProjectFilterForm,
    ProjectFilterRealtyForm,
    RealtyForm,
)


class ProjectView(BaseMixin, View):
    template_name = 'project_detail.html'
    form_class = ContractorProjectAnswerForm
    
    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**_.merge({}, request.GET, kwargs))
        
        project = get_object_or_404(Project, pk=kwargs.get('pk'))
        context.update({'project': project})
        
        # context.update({'tmp_answer': Answer.objects.order_by('?').first()})
        
        # import code; code.interact(local=dict(globals(), **locals()))
        
        if request.user.is_authenticated() and request.user.is_contractor():
            form = self.form_class()
            context.update({'form': form})
        
        return render(request, self.template_name, context)


class ProjectFilterView(BaseMixin, View):
    template_name = 'project_filter.html'
    form_class = ProjectFilterForm
    realty_form = ProjectFilterRealtyForm
    
    def get(self, request, *args, **kwargs):
        form = self.form_class(request.GET, request=request)
        realty_form = self.realty_form(request.GET, request=request, prefix='realty_form')
        context = self.get_context_data(**_.merge({}, request.GET, kwargs))
        
        projects = Project.objects
        
        if form.is_valid() and realty_form.is_valid():
            ord = None
            
            keywords = form.cleaned_data.get('keywords')
            cro = form.cleaned_data.get('cro')
            work_type = form.cleaned_data.get('work_type')
            specialization = form.cleaned_data.get('specialization')
            
            building_classification = realty_form.cleaned_data.get('building_classification')
            construction_type = realty_form.cleaned_data.get('construction_type')
            location = realty_form.cleaned_data.get('location')
            
            if keywords:
                keywords = tuple(filter(None, re.split(r'\s|,|;', keywords)))
                
                for k in keywords:
                    projects = projects.filter(Q(name__icontains=k) | Q(text__icontains=k))
            
            projects = projects.filter(cro=cro)
            
            if work_type:
                projects = projects.filter(work_type=work_type)
            
            if specialization:
                projects = projects.filter(
                    specialization__lft__gte=specialization.lft,
                    specialization__rght__lte=specialization.rght,
                )
            
            if building_classification:
                projects = projects.filter(realty__building_classification=building_classification)
            
            if construction_type:
                projects = projects.filter(realty__construction_type=construction_type)
            
            if location:
                projects = projects.filter(
                    realty__location__lft__gte=location.lft,
                    realty__location__rght__lte=location.rght,
                )
            
            order_by = form.cleaned_data.get('order_by')
            last_order_by = form.cleaned_data.get('last_order_by')
            reverse_order = form.cleaned_data.get('reverse_order')
            
            if order_by:
                reverse_order = not reverse_order if order_by == last_order_by else False
                ord = order_by
                last_order_by = ord
            elif last_order_by:
                ord = last_order_by
            
            if ord:
                projects = projects.order_by('-%s' % ord if reverse_order else ord)
            
            context.update({
                'last_order_by': last_order_by,
                'reverse_order': reverse_order,
            })
            
            project_count = projects.count()
            display_msg = 'Найдено %s проектов' % project_count if project_count > 0 else 'Ничего не найдено'
        else:
            display_msg = 'Пожалуйста, введите корректные данные'
            
            if form.errors:
                messages.info(request, (
                    '<p>Произошла ошибка (form)</p>'
                    '<pre>{form}</pre>'
                ).format(form=pformat(form.errors)))
            
            if realty_form and realty_form.errors:
                messages.info(request, (
                    '<p>Произошла ошибка (realty_form)</p>'
                    '<pre>{realty_form}</pre>'
                ).format(realty_form=pformat(realty_form.errors)))
        
        
        paginator = Paginator(projects.all(), settings.PAGE_SIZE)
        page = request.GET.get('page')
        
        try:
            projects = paginator.page(page)
        except PageNotAnInteger:
            projects = paginator.page(1)
        except EmptyPage:
            projects = paginator.page(paginator.num_pages)
        
        context.update({
            'form': form,
            'realty_form': realty_form,
            'projects': projects,
            'is_paginated': True,
            'page_obj': projects,
            'display_msg': display_msg,
        })
        
        return render(request, self.template_name, context)


class CustomerProjectCreateView(BaseMixin, View):
    form_class = CustomerProjectEditForm
    realty_form = RealtyForm
    template_name = 'customer_project_create.html'
    
    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated() and request.user.is_customer() and request.user.pk == int(kwargs.get('pk')):
            return super().dispatch(request, *args, **kwargs)
        else:
            return HttpResponseForbidden('403 Forbidden')
    
    def get(self, request, *args, **kwargs):
        form = self.form_class(request=request)
        realty_form = self.realty_form(request=request, prefix='realty_form')
        
        context = self.get_context_data(**_.merge({}, request.GET, kwargs))
        context.update({'form': form, 'realty_form': realty_form})
        
        return render(request, self.template_name, context)
    
    def post(self, request, *args, **kwargs):
        form = self.form_class(request.POST, request.FILES, request=request)
        
        form.is_valid()
        realty = form.cleaned_data.get('realty')
        
        if realty:
            realty_form = self.realty_form(request.POST, instance=realty, request=request, prefix='realty_form')
        else:
            realty_form = self.realty_form(request.POST, request=request, prefix='realty_form')
        
        if form.is_valid() and realty_form.is_valid():
            project = form.save(commit=False)
            project.customer = request.user
            project.save()
            form.save_m2m()
            
            Order.objects.create(project=project)
            
            for file in request.FILES.getlist('new_files'):
                proj_file = ProjectFile.objects.create(file=file, project=project)
                proj_file.save()
            
            if realty:
                realty_form.save()
            else:
                realty = realty_form.save(commit=False)
                realty.user = request.user
                realty.save()
                realty_form.save_m2m()
                
                project.realty = realty # Connect a realty with a project
                project.save()
            
            messages.info(request, 'Проект успешно создан')
            redirect_to = reverse('projects:detail', kwargs={'pk': project.pk})
            return redirect(redirect_to)
        else:
            if form.errors:
                messages.info(request, (
                    '<p>Произошла ошибка (form)</p>'
                    '<pre>{form}</pre>'
                ).format(form=pformat(form.errors)))
            
            if realty_form and realty_form.errors:
                messages.info(request, (
                    '<p>Произошла ошибка (realty_form)</p>'
                    '<pre>{realty_form}</pre>'
                ).format(realty_form=pformat(realty_form.errors)))
            
            context = self.get_context_data(**kwargs)
            context.update({'form': form, 'realty_form': realty_form})
            return render(request, self.template_name, context)


class CustomerProjectEditView(BaseMixin, View):
    form_class = CustomerProjectEditForm
    realty_form = RealtyForm
    template_name = 'customer_project_edit.html'
    
    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated() and request.user.is_customer():
            return super().dispatch(request, *args, **kwargs)
        else:
            return HttpResponseForbidden('403 Forbidden')
    
    def get(self, request, *args, **kwargs):
        project = get_object_or_404(request.user.projects, pk=kwargs.get('pk'))
        form = self.form_class(instance=project, request=request)
        
        realty = project.realty
        
        if realty:
            realty_form = self.realty_form(instance=project.realty, request=request, prefix='realty_form')
        else:
            realty_form = self.realty_form(request=request, prefix='realty_form')
        
        context = self.get_context_data(**_.merge({}, request.GET, kwargs))
        context.update({'form': form, 'realty_form': realty_form})
        
        return render(request, self.template_name, context)
    
    def post(self, request, *args, **kwargs):
        project = get_object_or_404(request.user.projects, pk=kwargs.get('pk'))
        form = self.form_class(request.POST, request.FILES, request=request, instance=project)
        
        form.is_valid()
        realty = form.cleaned_data.get('realty')
        
        if realty:
            realty_form = self.realty_form(request.POST, instance=realty, request=request, prefix='realty_form')
        else:
            realty_form = self.realty_form(request.POST, request=request, prefix='realty_form')
        
        if form.is_valid() and realty_form.is_valid():
            project = form.save(commit=False)
            project.customer = request.user
            project.files = form.cleaned_data.get('files') # TODO: Somehow get rid of this explicit assignment
            project.save()
            form.save_m2m()
            
            for file in request.FILES.getlist('new_files'):
                proj_file = ProjectFile.objects.create(file=file, project=project)
                proj_file.save()
            
            if realty:
                realty_form.save()
            else:
                realty = realty_form.save(commit=False)
                realty.user = request.user
                realty.save()
                realty_form.save_m2m()
                
                project.realty = realty # Connect a realty with a project
                project.save()
            
            messages.info(request, 'Проект успешно отредактирован')
            redirect_to = request.POST.get('next')
            return redirect(redirect_to)
        else:
            if form.errors:
                messages.info(request, (
                    '<p>Произошла ошибка (form)</p>'
                    '<pre>{form}</pre>'
                ).format(form=pformat(form.errors)))
            
            if realty_form and realty_form.errors:
                messages.info(request, (
                    '<p>Произошла ошибка (realty_form)</p>'
                    '<pre>{realty_form}</pre>'
                ).format(realty_form=pformat(realty_form.errors)))
            
            context = self.get_context_data(**kwargs)
            context.update({'form': form, 'realty_form': realty_form})
            return render(request, self.template_name, context)


class ContractorProjectAnswerView(BaseMixin, View):
    form_class = ContractorProjectAnswerForm
    
    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated() and request.user.is_contractor():
            return super().dispatch(request, *args, **kwargs)
        else:
            return HttpResponseForbidden('403 Forbidden')
    
    def post(self, req, *args, **kwargs):
        form = self.form_class(_.merge({}, req.POST, kwargs), req=req)
        
        if form.is_valid():
            project = form.cleaned_data.get('pk')
            project.state = 'trashed'
            project.save()
            
            messages.info(req, 'OK')
        else:
            messages.info(req, 'Произошла ошибка: <pre>{msg}</pre>'.format(msg=pformat(form.errors)))
        
        redirect_to = req.POST.get('next')
        return redirect(redirect_to)
    
    
    
    # def post(self, request, *args, **kwargs):
    #     form = self.form_class(request.POST)
    #     project = get_object_or_404(Project, pk=kwargs.get('pk'))
    #     if form.is_valid():
    #         answer = form.save(commit=False)
    #         answer.contractor = request.user
    #         answer.project = project
    #         answer.save()
    #         return HttpResponseRedirect(reverse('projects:detail', kwargs={'pk': project.pk}))
    #     return render(request, self.template_name, {'project': project,  'form': self.form_class})



class PortfolioTrashView(View):
    pass


class CustomerProjectTrashView(View):
    form_class = CustomerProjectTrashForm
    
    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated() and request.user.is_customer():
            return super().dispatch(request, *args, **kwargs)
        else:
            return HttpResponseForbidden('403 Forbidden')
    
    def post(self, req, *args, **kwargs):
        form = self.form_class(_.merge({}, req.POST, kwargs), req=req)
        
        if form.is_valid():
            project = form.cleaned_data.get('pk')
            project.state = 'trashed'
            project.save()

            messages.info(req, 'Проект перемещён в корзину')
        else:
            messages.info(req, 'Произошла ошибка: <pre>{msg}</pre>'.format(msg=pformat(form.errors)))
        
        redirect_to = req.POST.get('next')
        return redirect(redirect_to)


class CustomerProjectRestoreView(View):
    form_class = CustomerProjectRestoreForm
    
    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated() and request.user.is_customer():
            return super().dispatch(request, *args, **kwargs)
        else:
            return HttpResponseForbidden('403 Forbidden')
    
    def post(self, req, *args, **kwargs):
        form = self.form_class(_.merge({}, req.POST, kwargs), req=req)
        
        if form.is_valid():
            project = form.cleaned_data.get('pk')
            project.state = 'active'
            project.save()

            messages.info(req, 'Проект восстановлен из корзины')
        else:
            messages.info(req, 'Произошла ошибка: <pre>{msg}</pre>'.format(msg=pformat(form.errors)))
        
        redirect_to = req.POST.get('next')
        return redirect(redirect_to)


class CustomerProjectDeleteView(View):
    form_class = CustomerProjectDeleteForm
    
    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated() and request.user.is_customer():
            return super().dispatch(request, *args, **kwargs)
        else:
            return HttpResponseForbidden('403 Forbidden')
    
    def post(self, req, *args, **kwargs):
        form = self.form_class(_.merge({}, req.POST, kwargs), req=req)
        
        if form.is_valid():
            project = form.cleaned_data.get('pk')
            project.state = 'deleted'
            project.save()
            messages.info(req, 'Проект удалён навсегда')
        else:
            messages.info(req, 'Произошла ошибка: <pre>{msg}</pre>'.format(msg=pformat(form.errors)))
        
        redirect_to = req.POST.get('next')
        return redirect(redirect_to)


class ProjectComparisonView(DetailView):
    model = Project
    template_name = 'comparison.html'

    def get_context_data(self, **kwargs):
        context = super().get_context_data()
        return context


def add_candidate(request, answer_id, project_id):
    answer = Answer.objects.get(pk=answer_id)
    project = Project.objects.get(pk=project_id)
    candidate = Candidate.objects.create(answer=answer, project=project)
    return HttpResponseRedirect(reverse('projects:detail',args=[project_id]))


class OfferOrderView(View):
    template_name = 'chattest.html'

    def get(self, request, *args, **kwargs):
        return render(request, self.template_name)


def contractor_portfolio_create(request):
    if request.is_ajax():
        form = PortfolioForm(data=request.POST)
        # import code; code.interact(local=dict(globals(), **locals()))
        if form.is_valid():
            instance = form.save(commit=False)
            instance.save()
            images_ids = request.POST.get('images-ids').split(';')[:-1]
            for pk in images_ids:
                picture = Picture.objects.get(pk=pk)
                temp_file = ContentFile(picture.file.read())
                temp_file.name = picture.file.name
                p_photo = PortfolioPhoto()
                p_photo.img = temp_file
                p_photo.portfolio = instance
                p_photo.save()
            data = {'status': 'ok'}
        else:
            data = {'status': 'no', 'form_errors': form.errors}
        return HttpResponse(json.dumps(data), content_type='application/json')
    else:
        raise Http404


class ContractorPortfolioUpdateView(UpdateView):
    model = Portfolio
    form_class = PortfolioForm
    template_name = 'contractor_portfolio_edit.html'

    def get_success_url(self):
        return reverse('proje')


# import code; code.interact(local=dict(globals(), **locals()))