import json
from pprint import pprint, pformat
import pydash as _

from django.contrib import messages
from django.contrib.auth.mixins import PermissionRequiredMixin, LoginRequiredMixin
from django.core.urlresolvers import reverse, reverse_lazy
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 .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))
        display_msg = 'Список проектов'
        
        projects = Project.objects
        
        if form.is_valid() and realty_form.is_valid():
            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')
            
            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,
                )
            
            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)))
        
        order_by = request.GET.get('order_by') # TODO: Validate
        
        if order_by:
            projects = projects.order_by(order_by)
        
        projects = projects[:10]
        
        context.update({
            'form': form,
            'realty_form': realty_form,
            'projects': 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()
                
                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()))