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
from django.shortcuts import render, get_object_or_404, redirect
from django.views.generic import ListView, DetailView, CreateView, View, TemplateView, FormView
from django.views.generic.base import ContextMixin
from pprint import pprint, pformat
import pydash as _

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

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


class CustomerProjectCreateView(BaseMixin, View):
    form_class = CustomerProjectCreateForm
    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)

            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=request)
            
            form.is_valid()
            realty = form.cleaned_data.get('realty')

            if realty:
                realty_form = self.realty_form(request.POST, instance=realty, request=request)
            else:
                realty_form = self.realty_form(request.POST, request=request)

            if form.is_valid() and realty_form.is_valid():
                project = form.save(commit=False)
                project.customer = request.user
                project.save()
                form.save_m2m()
                
                if realty:
                    realty_form.save()
                else:
                    realty = realty_form.save(commit=False)
                    realty.user = request.user
                    realty.save()
                    realty_form.save_m2m()

                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 ProjectsView(ListView):
    model = Project
    template_name = 'project_list.html'


class ProjectView(BaseMixin, View):
    template_name = 'project_detail.html'
    customer_template_name = 'customer_project_detail.html'
    
    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:
            return render(request, self.template_name, context)


class CustomerProjectEditView(BaseMixin, View):
    form_class = CustomerProjectEditForm
    template_name = 'customer_project_edit_test.html' # 'customer_project_edit.html'
    
    def get(self, req, *args, **kwargs):
        if req.user.is_authenticated():
            project = get_object_or_404(req.user.projects, pk=kwargs.get('pk'))
            form = self.form_class(instance=project, req=req)
            
            context = self.get_context_data(**_.merge({}, req.GET, kwargs))
            context.update({'form': form})
            
            return render(req, self.template_name, context)
        else:
            return HttpResponseForbidden('403 Forbidden')
    
    def post(self, req, *args, **kwargs):
        if req.user.is_authenticated():
            project = get_object_or_404(req.user.projects, pk=kwargs.get('pk'))
            form = self.form_class(_.merge({}, req.POST, kwargs), req=req, instance=project)
            
            if form.is_valid():
                form.save()
                
                messages.info(req, 'Проект успешно отредактирован')
                redirect_to = req.POST.get('next')
                return redirect(redirect_to)
            else:
                context = self.get_context_data(**kwargs)
                context.update({'form': form})
                
                messages.info(req, 'Произошла ошибка: <pre>{msg}</pre>'.format(msg=pformat(form.errors)))
                return render(req, 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()
        order = Order.objects.create(project=project)
        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 ChatView(View):
    template_name = 'chat.html'

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


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

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