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.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
import json
import pydash as _; _.map = _.map_; _.filter = _.filter_
import re

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

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


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():
            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:
                if order_by == last_order_by:
                    reverse_order = not reverse_order
                else:
                    reverse_order = False
                
                projects = projects.order_by('-%s' % order_by if reverse_order else order_by)
                last_order_by = order_by
            elif last_order_by:
                projects = projects.order_by('-%s' % last_order_by if reverse_order else last_order_by)
            
            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 ProjectView(BaseMixin, View):
    template_name = 'project_detail.html'
    customer_template_name = 'customer_project_detail.html'
    form_class = ContractorProjectAnswerForm
    
    def get(self, request, *args, **kwargs):
        project = get_object_or_404(Project, pk=kwargs.get('pk'))

        context = self.get_context_data(**_.merge({}, request.GET, kwargs))
        context.update({'project': project})

        if request.user.is_authenticated() and request.user.is_customer():
            return render(request, self.customer_template_name, context)
        else:
            form = self.form_class()
            context.update({'form': form})
            return render(request, self.template_name, context)


class CustomerProjectCreateView(BaseMixin, View):
    form_class = CustomerProjectEditForm
    realty_form = RealtyForm
    template_name = 'customer_project_create.html'
    
    def get(self, request, *args, **kwargs):
        if request.user.is_authenticated() and request.user.is_customer():
            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)
        else:
            return HttpResponseForbidden('403 Forbidden')
    
    def post(self, request, *args, **kwargs):
        if request.user.is_authenticated() and request.user.is_customer():
            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)
        else:
            return HttpResponseForbidden('403 Forbidden')


class CustomerProjectEditView(BaseMixin, View):
    form_class = CustomerProjectEditForm
    realty_form = RealtyForm
    template_name = 'customer_project_edit.html'
    
    def get(self, request, *args, **kwargs):
        if request.user.is_authenticated() and request.user.is_customer():
            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)
        else:
            return HttpResponseForbidden('403 Forbidden')
    
    def post(self, request, *args, **kwargs):
        if request.user.is_authenticated() and request.user.is_customer():
            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)
        else:
            return HttpResponseForbidden('403 Forbidden')


class ContractorProjectAnswerView(BaseMixin, View):
    form_class = ContractorProjectAnswerForm
    
    def post(self, request, *args, **kwargs):
        if not request.user.is_authenticated():
            return HttpResponseForbidden()
        form = self.form_class(request.POST)
        project = get_object_or_404(Project, pk=kwargs.get('pk'))
        if form.is_valid():
            return self.form_valid(request, form, project)
        return render(request, self.template_name, {'project': project,  'form': self.form_class})
    
    def form_valid(self, request, form, project):
        answer = form.save(commit=False)
        answer.contractor = request.user
        answer.project = project
        answer.save()
        return HttpResponseRedirect(reverse('projects:detail', kwargs={'pk': project.pk}))


class CustomerProjectTrashView(View):
    form_class = CustomerProjectTrashForm
    
    def post(self, req, *args, **kwargs):
        if req.user.is_authenticated():
            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)))
        else:
            return HttpResponseForbidden('403 Forbidden')
        
        redirect_to = req.POST.get('next')
        return redirect(redirect_to)


class CustomerProjectRestoreView(View):
    form_class = CustomerProjectRestoreForm
    
    def post(self, req, *args, **kwargs):
        if req.user.is_authenticated():
            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)))
        else:
            return HttpResponseForbidden('403 Forbidden')
        
        redirect_to = req.POST.get('next')
        return redirect(redirect_to)


class CustomerProjectDeleteView(View):
    form_class = CustomerProjectDeleteForm
    
    def post(self, req, *args, **kwargs):
        if req.user.is_authenticated():
            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)))
        else:
            return HttpResponseForbidden('403 Forbidden')
        
        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)
        if form.is_valid():
            instance = form.save(commit=False)
            instance.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()))