import logging
import uuid
from datetime import datetime
from urllib.parse import quote
from time import sleep

import stripe
from django import forms
from django.conf import settings
from django.contrib import messages
from django.contrib.auth.mixins import LoginRequiredMixin
from django.contrib.auth.tokens import default_token_generator
from django.core.exceptions import ValidationError
from django.core.files.base import ContentFile
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.core.urlresolvers import reverse_lazy, reverse
from django.db.models import Q
from django.http import (
    Http404, HttpResponseRedirect, HttpResponse, JsonResponse
)
from django.shortcuts import redirect, render
from django.utils.decorators import method_decorator
from django.utils.html import escape
from django.utils.http import urlsafe_base64_decode
from django.utils.safestring import mark_safe
from django.utils.translation import get_language, ugettext_lazy as _
from django.utils.translation import ugettext
from django.views.decorators.cache import never_cache
from django.views.generic import (
    View, CreateView, FormView, ListView, DetailView, DeleteView,
    TemplateView, UpdateView
)
from guardian.mixins import PermissionRequiredMixin
from oca.pool import WrongIdError
from rest_framework.renderers import JSONRenderer
from rest_framework.response import Response
from rest_framework.views import APIView
from stored_messages.api import mark_read
from stored_messages.models import Message
from stored_messages.settings import stored_messages_settings

from datacenterlight.cms_models import DCLCalculatorPluginModel
from datacenterlight.models import VMTemplate, VMPricing
from datacenterlight.utils import (
    create_vm, get_cms_integration, check_otp, validate_vat_number
)
from hosting.models import UserCardDetail, StripeTaxRate
from membership.models import CustomUser, StripeCustomer
from opennebula_api.models import OpenNebulaManager
from opennebula_api.serializers import (
    VirtualMachineSerializer, VirtualMachineTemplateSerializer,
    VMTemplateSerializer
)
from utils.forms import (
    BillingAddressForm, PasswordResetRequestForm, UserBillingAddressForm,
    ResendActivationEmailForm
)
from utils.hosting_utils import get_all_public_keys
from utils.hosting_utils import (
    get_vm_price_with_vat, get_vm_price_for_given_vat, HostingUtils,
    get_vat_rate_for_country
)
from utils.ldap_manager import LdapManager
from utils.mailer import BaseEmail
from utils.stripe_utils import StripeUtils
from utils.tasks import send_plain_email_task
from utils.views import (
    PasswordResetViewMixin, PasswordResetConfirmViewMixin, LoginViewMixin,
    ResendActivationLinkViewMixin
)
from .forms import (
    HostingUserSignupForm, HostingUserLoginForm, UserHostingKeyForm,
    generate_ssh_key_name
)
from .mixins import ProcessVMSelectionMixin, HostingContextMixin
from .models import (
    HostingOrder, HostingBill, HostingPlan, UserHostingKey, VMDetail,
    GenericProduct, MonthlyHostingBill
)

logger = logging.getLogger(__name__)


CONNECTION_ERROR = "Your VMs cannot be displayed at the moment due to a \
                    backend connection error. please try again in a few \
                    minutes."


decorators = [never_cache]


class DashboardView(LoginRequiredMixin, View):
    template_name = "hosting/dashboard.html"
    login_url = reverse_lazy('hosting:login')

    def get_context_data(self, **kwargs):
        context = {}
        return context

    @method_decorator(decorators)
    def get(self, request, *args, **kwargs):
        context = self.get_context_data()
        context['has_invoices'] = False
        try:
            bills = []
            if hasattr(self.request.user, 'stripecustomer'):
                bills = MonthlyHostingBill.objects.filter(
                    customer=self.request.user.stripecustomer
                )
            if len(bills) > 0:
                context['has_invoices'] = True
        except MonthlyHostingBill.DoesNotExist as dne:
            logger.error("{}'s monthly hosting bill not imported ?".format(
                self.request.user.email
            ))
        return render(request, self.template_name, context)


class DjangoHostingView(ProcessVMSelectionMixin, View):
    template_name = "hosting/django.html"

    def get_context_data(self, **kwargs):
        HOSTING = 'django'
        templates = OpenNebulaManager().get_templates()
        data = VirtualMachineTemplateSerializer(templates, many=True).data
        configuration_options = HostingPlan.get_serialized_configs()
        context = {
            'hosting': HOSTING,
            'hosting_long': "Django",
            # 'configuration_detail': configuration_detail,
            'domain': "django-hosting.ch",
            'google_analytics': "UA-62285904-6",
            'vm_types': data,
            'email': "info@django-hosting.ch",
            'configuration_options': configuration_options,
            'templates': templates,
        }

        return context

    def get(self, request, *args, **kwargs):
        request.session['hosting_url'] = reverse('hosting:djangohosting')
        context = self.get_context_data()

        return render(request, self.template_name, context)


class RailsHostingView(ProcessVMSelectionMixin, View):
    template_name = "hosting/rails.html"

    def get_context_data(self, **kwargs):
        HOSTING = 'rails'

        templates = OpenNebulaManager().get_templates()
        configuration_options = HostingPlan.get_serialized_configs()

        context = {
            'hosting': HOSTING,
            'hosting_long': "Ruby On Rails",
            'domain': "rails-hosting.ch",
            'google_analytics': "UA-62285904-5",
            'email': "info@rails-hosting.ch",
            'configuration_options': configuration_options,
            'templates': templates,
        }
        return context

    def get(self, request, *args, **kwargs):
        request.session['hosting_url'] = reverse('hosting:railshosting')
        context = self.get_context_data()
        return render(request, self.template_name, context)


class NodeJSHostingView(ProcessVMSelectionMixin, View):
    template_name = "hosting/nodejs.html"

    def get_context_data(self, **kwargs):
        HOSTING = 'nodejs'
        templates = OpenNebulaManager().get_templates()
        configuration_options = HostingPlan.get_serialized_configs()

        context = {
            'hosting': HOSTING,
            'hosting_long': "NodeJS",
            # 'configuration_detail': configuration_detail,
            'domain': "node-hosting.ch",
            'google_analytics': "UA-62285904-7",
            'email': "info@node-hosting.ch",
            'templates': templates,
            'configuration_options': configuration_options,

        }
        return context

    def get(self, request, *args, **kwargs):
        request.session['hosting_url'] = reverse('hosting:nodejshosting')
        context = self.get_context_data()

        return render(request, self.template_name, context)


class HostingPricingView(ProcessVMSelectionMixin, View):
    template_name = "hosting/hosting_pricing.html"

    def get_context_data(self, **kwargs):
        # configuration_options = dict(VirtualMachinePlan.VM_CONFIGURATION)
        templates = OpenNebulaManager().get_templates()
        configuration_options = HostingPlan.get_serialized_configs()

        context = {
            # 'configuration_options': configuration_options,
            'email': "info@django-hosting.ch",
            'templates': templates,
            'configuration_options': configuration_options,

        }

        return context

    def get(self, request, *args, **kwargs):
        request.session['hosting_url'] = reverse('hosting:djangohosting')
        context = self.get_context_data()

        return render(request, self.template_name, context)


class IndexView(View):
    template_name = "hosting/index.html"

    def get_context_data(self, **kwargs):
        templates = OpenNebulaManager().get_templates()
        data = VirtualMachineTemplateSerializer(templates, many=True).data

        context = {
            'hosting': "nodejs",
            'hosting_long': "NodeJS",
            'domain': "node-hosting.ch",
            'google_analytics': "UA-62285904-7",
            'email': "info@node-hosting.ch",
            'vm_types': data
            # 'vm_types': VirtualMachineType.get_serialized_vm_types(),
        }
        return context

    @method_decorator(decorators)
    def get(self, request, *args, **kwargs):
        context = self.get_context_data()
        return render(request, self.template_name, context)


class LoginView(HostingContextMixin, LoginViewMixin):
    template_name = "hosting/login.html"
    form_class = HostingUserLoginForm
    success_url = reverse_lazy('hosting:dashboard')


class SignupView(HostingContextMixin, CreateView):
    template_name = 'hosting/signup.html'
    form_class = HostingUserSignupForm
    model = CustomUser
    success_url = reverse_lazy('hosting:dashboard')

    def get_success_url(self):
        next_url = self.request.session.get(
            'next', self.success_url)
        return next_url

    def form_valid(self, form):
        name = form.cleaned_data.get('name')
        email = form.cleaned_data.get('email')
        password = form.cleaned_data.get('password')
        this_base_url = "{0}://{1}".format(self.request.scheme,
                                           self.request.get_host())
        CustomUser.register(name, password, email,
                            app='dcl', base_url=this_base_url)

        return HttpResponseRedirect(reverse_lazy('hosting:signup-validate'))

    @method_decorator(decorators)
    def get(self, request, *args, **kwargs):
        if self.request.user.is_authenticated():
            return HttpResponseRedirect(self.get_success_url())
        return super(SignupView, self).get(request, *args, **kwargs)


class SignupValidateView(HostingContextMixin, TemplateView):
    template_name = "hosting/signup_validate.html"

    def get_context_data(self, **kwargs):
        context = super(SignupValidateView, self).get_context_data(**kwargs)
        login_url = '<a href="' + \
                    reverse('hosting:login') + '">' + str(_('login')) + '</a>'
        home_url = '<a href="' + \
                   reverse('datacenterlight:index') + '">Data Center Light</a>'
        message = '{signup_success_message} {lurl}</a> \
                 <br />{go_back} {hurl}.'.format(
            signup_success_message=_(
                'Thank you for signing up. We have sent an email to you. '
                'Please follow the instructions in it to activate your '
                'account. Once activated, you can login using'),
            go_back=_('Go back to'),
            lurl=login_url,
            hurl=home_url
        )
        context['message'] = mark_safe(message)
        context['section_title'] = _('Sign up')
        return context


class SignupValidatedView(SignupValidateView, HostingContextMixin):
    template_name = "hosting/signup_validate.html"

    def get_context_data(self, **kwargs):
        context = super(SignupValidateView, self).get_context_data(**kwargs)
        validated = CustomUser.validate_url(self.kwargs['validate_slug'])
        login_url = '<a href="' + \
                    reverse('hosting:login') + '">' + str(_('login')) + '</a>'
        section_title = _('Account activation')
        user = CustomUser.objects.filter(
            validation_slug=self.kwargs['validate_slug']).first()
        if validated:
            message = ('{account_activation_string} <br />'
                       ' {login_string} {lurl}.').format(
                account_activation_string=_(
                    "Your account has been activated."),
                login_string=_("You can now"),
                lurl=login_url)
            email_data = {
                'subject': _('Welcome to Data Center Light!'),
                'to': user.email,
                'context': {
                    'base_url': "{0}://{1}".format(
                        self.request.scheme,
                        self.request.get_host()
                    )
                },
                'template_name': 'welcome_user',
                'template_path': 'datacenterlight/emails/',
                'from_address': settings.DCL_SUPPORT_FROM_ADDRESS,
            }
            email = BaseEmail(**email_data)
            email.send()
        else:
            home_url = '<a href="' + \
                       reverse('datacenterlight:cms_index') + \
                       '">Data Center Light</a>'
            message = '{sorry_message} <br />{go_back_to} {hurl}'.format(
                sorry_message=_("Sorry. Your request is invalid."),
                go_back_to=_('Go back to'),
                hurl=home_url
            )
        context['message'] = mark_safe(message)
        context['section_title'] = section_title
        return context

    @method_decorator(decorators)
    def get(self, request, *args, **kwargs):
        if self.request.user.is_authenticated():
            return HttpResponseRedirect(reverse_lazy('hosting:dashboard'))
        return super(SignupValidatedView, self).get(request, *args, **kwargs)


class ResendActivationEmailView(HostingContextMixin,
                                ResendActivationLinkViewMixin):
    template_name = 'hosting/resend_activation_link.html'
    form_class = ResendActivationEmailForm
    success_url = reverse_lazy('hosting:login')
    email_template_path = 'datacenterlight/emails/'
    email_template_name = 'user_activation'


class PasswordResetView(HostingContextMixin, PasswordResetViewMixin):
    site = 'dcl'
    template_name = 'hosting/reset_password.html'
    form_class = PasswordResetRequestForm
    success_url = reverse_lazy('hosting:login')
    template_email_path = 'hosting/emails/'


class PasswordResetConfirmView(HostingContextMixin,
                               PasswordResetConfirmViewMixin):
    template_name = 'hosting/confirm_reset_password.html'
    success_url = reverse_lazy('hosting:login')

    def post(self, request, uidb64=None, token=None, *arg, **kwargs):
        try:
            uid = urlsafe_base64_decode(uidb64)
            user = CustomUser.objects.get(pk=uid)

            opennebula_client = OpenNebulaManager(
                email=user.username,
                password=user.password,
            )

        except (TypeError, ValueError, OverflowError, CustomUser.DoesNotExist):
            user = None
            opennebula_client = None

        form = self.form_class(request.POST)

        if user is not None and default_token_generator.check_token(user,
                                                                    token):
            if form.is_valid():
                ldap_manager = LdapManager()
                new_password = form.cleaned_data['new_password2']

                # Make sure the user have an ldap account already
                user.create_ldap_account(new_password)

                # We are changing password in ldap before changing in database because
                # ldap have more chances of failure than local database
                if ldap_manager.change_password(user.username, new_password):
                    user.set_password(new_password)
                    user.save()

                    messages.success(request, _('Password has been reset.'))

                    # Change opennebula password
                    opennebula_client.change_user_password(user.password)

                    return self.form_valid(form)

            messages.error(
                request, _('Password reset has not been successful.'))
            form.add_error(None,
                           _('Password reset has not been successful.'))
            return self.form_invalid(form)

        else:
            error_msg = _('The reset password link is no longer valid.')
            messages.error(request, _(error_msg))
            form.add_error(None, error_msg)
            return self.form_invalid(form)


class NotificationsView(LoginRequiredMixin, TemplateView):
    template_name = 'hosting/notifications.html'
    login_url = reverse_lazy('hosting:login')

    def get_context_data(self, **kwargs):
        context = super(NotificationsView, self).get_context_data(**kwargs)
        backend = stored_messages_settings.STORAGE_BACKEND()
        unread_notifications = backend.inbox_list(self.request.user)
        read_notifications = backend.archive_list(self.request.user)
        context.update({
            'unread_notifications': unread_notifications,
            'all_notifications': read_notifications + unread_notifications
        })
        return context


class MarkAsReadNotificationView(LoginRequiredMixin, UpdateView):
    model = Message
    success_url = reverse_lazy('hosting:notifications')
    login_url = reverse_lazy('hosting:login')
    fields = '__all__'

    def post(self, *args, **kwargs):
        message = self.get_object()
        backend = stored_messages_settings.STORAGE_BACKEND()
        backend.archive_store([self.request.user], message)
        mark_read(self.request.user, message)
        return HttpResponseRedirect(reverse('hosting:notifications'))


class SSHKeyDeleteView(LoginRequiredMixin, DeleteView):
    login_url = reverse_lazy('hosting:login')
    success_url = reverse_lazy('hosting:ssh_keys')
    model = UserHostingKey

    def get_object(self, queryset=None):
        """ Hook to ensure UserHostingKey object is owned by request.user.
            We reply with a Http404 if the user is not the owner of the key.
        """
        obj = super(SSHKeyDeleteView, self).get_object()
        if not obj.user == self.request.user:
            raise Http404
        return obj

    def delete(self, request, *args, **kwargs):
        owner = self.request.user
        manager = OpenNebulaManager(
            email=owner.username,
            password=owner.password
        )
        pk = self.kwargs.get('pk')
        # Get user ssh key
        public_key = UserHostingKey.objects.get(pk=pk).public_key
        keys = UserHostingKey.objects.filter(user=self.request.user)
        keys_to_save = [k.public_key for k in keys if k.public_key != public_key]
        manager.save_key_in_opennebula_user('\n'.join(keys_to_save), update_type=0)

        return super(SSHKeyDeleteView, self).delete(request, *args, **kwargs)


class SSHKeyListView(LoginRequiredMixin, ListView):
    template_name = "hosting/user_keys.html"
    login_url = reverse_lazy('hosting:login')
    context_object_name = "keys"
    model = UserHostingKey
    paginate_by = 10
    ordering = '-id'

    def get_queryset(self):
        user = self.request.user
        self.queryset = UserHostingKey.objects.filter(user=user)
        return super(SSHKeyListView, self).get_queryset()

    @method_decorator(decorators)
    def render_to_response(self, context, **response_kwargs):
        if not self.queryset:
            return HttpResponseRedirect(reverse('hosting:choice_ssh_keys'))
        return super(SSHKeyListView, self).render_to_response(context,
                                                              **response_kwargs)


class SSHKeyChoiceView(LoginRequiredMixin, View):
    template_name = "hosting/choice_ssh_keys.html"
    login_url = reverse_lazy('hosting:login')

    @method_decorator(decorators)
    def get(self, request, *args, **kwargs):
        context = {}
        return render(request, self.template_name, context)

    @method_decorator(decorators)
    def post(self, request, *args, **kwargs):
        name = generate_ssh_key_name()
        private_key, public_key = UserHostingKey.generate_keys()
        content = ContentFile(private_key)
        ssh_key = UserHostingKey.objects.create(
            user=request.user, public_key=public_key, name=name)
        filename = name + '_' + str(uuid.uuid4())[:8] + '_private.pem'
        ssh_key.private_key.save(filename, content)
        owner = self.request.user
        manager = OpenNebulaManager(
            email=owner.username,
            password=owner.password
        )
        keys = get_all_public_keys(request.user)
        manager.save_key_in_opennebula_user('\n'.join(keys))
        return redirect(reverse_lazy('hosting:ssh_keys'), foo='bar')


@method_decorator(decorators, name='dispatch')
class SettingsView(LoginRequiredMixin, FormView):
    template_name = "hosting/settings.html"
    login_url = reverse_lazy('hosting:login')
    form_class = BillingAddressForm
    permission_required = ['view_usercarddetail']

    def get_form(self, form_class):
        """
        Check if the user already saved contact details. If so, then show
        the form populated with those details, to let user change them.
        """
        username = self.request.GET.get('username')
        if self.request.user.is_admin and username:
            user = CustomUser.objects.get(username=username)
        else:
            user = self.request.user
        return form_class(
            instance=user.billing_addresses.first(),
            **self.get_form_kwargs())

    def get_context_data(self, **kwargs):
        context = super(SettingsView, self).get_context_data(**kwargs)
        # Get user
        username = self.request.GET.get('username')
        if self.request.user.is_admin and username:
            user = CustomUser.objects.get(username=username)
        else:
            user = self.request.user
        stripe_customer = None
        if hasattr(user, 'stripecustomer'):
            stripe_customer = user.stripecustomer
        stripe_utils = StripeUtils()
        cards_list_request = stripe_utils.get_available_payment_methods(
            stripe_customer
        )
        cards_list = cards_list_request.get('response_object')
        context.update({
            'cards_list': cards_list,
            'stripe_key': settings.STRIPE_API_PUBLIC_KEY
        })

        return context

    def post(self, request, *args, **kwargs):
        if 'card' in request.POST and request.POST['card'] is not '':
            card_id = escape(request.POST['card'])
            UserCardDetail.set_default_card(
                stripe_api_cus_id=request.user.stripecustomer.stripe_id,
                stripe_source_id=card_id
            )
            stripe_utils = StripeUtils()
            card_details = stripe_utils.get_cards_details_from_payment_method(
                card_id
            )
            if not card_details.get('response_object'):
                logger.debug("Could not find card %s in stripe" % card_id)
                messages.add_message(request, messages.ERROR,
                                     _("Could not set a default card."))
                return HttpResponseRedirect(reverse_lazy('hosting:settings'))
            card_details_response = card_details['response_object']
            msg = _(
                ("Your {brand} card ending in {last4} set as "
                 "default card").format(
                    brand=card_details_response['brand'],
                    last4=card_details_response['last4']
                )
            )
            messages.add_message(request, messages.SUCCESS, msg)
            return HttpResponseRedirect(reverse_lazy('hosting:settings'))
        if 'delete_card' in request.POST:
            card = self.kwargs.get('pk')
            stripe_utils = StripeUtils()
            stripe_utils.dissociate_customer_card(
                request.user.stripecustomer.stripe_id,
                card
            )
            msg = _("Card deassociation successful")
            messages.add_message(request, messages.SUCCESS, msg)
            return HttpResponseRedirect(reverse_lazy('hosting:settings'))
        form = self.get_form()
        if form.is_valid():
            if 'billing-form' in request.POST:
                current_billing_address = self.request.user.billing_addresses.last()
                billing_address_data = form.cleaned_data
                billing_address_data.update({
                    'user': self.request.user.id
                })
                billing_address_user_form = UserBillingAddressForm(
                    instance=self.request.user.billing_addresses.order_by('-id').first(),
                    data=billing_address_data)
                billing_address = billing_address_user_form.save()
                billing_address.stripe_tax_id = ''
                billing_address.vat_number_validated_on = None
                billing_address.vat_validation_status = ''
                billing_address.save()
                vat_number = billing_address_user_form.cleaned_data.get(
                    'vat_number').strip()
                logger.debug("Vat number = %s" % vat_number)
                if vat_number:
                    try:
                        stripe_customer = request.user.stripecustomer
                    except StripeCustomer.DoesNotExist as dne:
                        logger.debug(
                            "User %s does not have a stripecustomer. "
                            "Creating one." % request.user.email)
                        stripe_customer = StripeCustomer.get_or_create(
                            email=request.user.email,
                            token=None)
                        request.user.stripecustomer = stripe_customer
                        request.user.save()
                    validate_result = validate_vat_number(
                        stripe_customer_id=request.user.stripecustomer.stripe_id,
                        billing_address_id=billing_address.id,
                        is_user_ba=True
                    )
                    logger.debug("validate_result = %s" % str(validate_result))
                    if 'error' in validate_result and validate_result['error']:
                        messages.add_message(
                            request, messages.ERROR,
                            "VAT Number validation error: %s" % validate_result["error"],
                            extra_tags='error'
                        )
                        billing_address = current_billing_address
                        if billing_address:
                            billing_address.save()
                        email_data = {
                            'subject': "%s updated VAT number to %s but failed" %
                                       (request.user.email, vat_number),
                            'from_email': settings.DCL_SUPPORT_FROM_ADDRESS,
                            'to': settings.DCL_ERROR_EMAILS_TO_LIST,
                            'body': "\n".join(
                                ["%s=%s" % (k, v) for (k, v) in
                                 validate_result.items()]),
                        }
                    else:
                        email_data = {
                            'subject': "%s updated VAT number to %s" % (
                                request.user.email, vat_number
                            ),
                            'from_email': settings.DCL_SUPPORT_FROM_ADDRESS,
                            'to': settings.DCL_ERROR_EMAILS_TO_LIST,
                            'body': "\n".join(
                                ["%s=%s" % (k, v) for (k, v) in
                                 validate_result.items()]),
                        }
                        msg = _("Billing address updated successfully")
                        messages.add_message(request, messages.SUCCESS, msg)
                    send_plain_email_task.delay(email_data)
                else:
                    msg = _("Billing address updated successfully")
                    messages.add_message(request, messages.SUCCESS, msg)
            else:
                id_payment_method = request.POST.get('id_payment_method', None)
                stripe_utils = StripeUtils()
                card_details = stripe_utils.get_cards_details_from_payment_method(
                    id_payment_method
                )
                if not card_details.get('response_object'):
                    form.add_error("__all__", card_details.get('error'))
                    return self.render_to_response(self.get_context_data())
                stripe_customer = StripeCustomer.get_or_create(
                    email=request.user.email, id_payment_method=id_payment_method
                )
                card = card_details['response_object']
                acc_result = stripe_utils.associate_customer_card(
                    request.user.stripecustomer.stripe_id,
                    id_payment_method,
                    set_as_default=True
                )
                if acc_result['response_object'] is None:
                    msg = _(
                        'An error occurred while associating the card.'
                        ' Details: {details}'.format(
                            details=acc_result['error']
                        )
                    )
                    messages.add_message(request, messages.ERROR, msg)
                    return self.render_to_response(self.get_context_data())
                preferred = False
                if stripe_customer.usercarddetail_set.count() == 0:
                    preferred = True
                UserCardDetail.create(
                    stripe_customer=stripe_customer,
                    last4=card['last4'],
                    brand=card['brand'],
                    fingerprint=card['fingerprint'],
                    exp_month=card['exp_month'],
                    exp_year=card['exp_year'],
                    card_id=card['card_id'],
                    preferred=preferred
                )
                msg = _(
                    "Successfully associated the card with your account"
                )
                messages.add_message(request, messages.SUCCESS, msg)
            return self.render_to_response(self.get_context_data())
        else:
            billing_address_data = form.cleaned_data
            return self.form_invalid(form)


class PaymentVMView(LoginRequiredMixin, FormView):
    template_name = 'hosting/payment.html'
    login_url = reverse_lazy('hosting:login')
    form_class = BillingAddressForm

    def get_form_kwargs(self):
        current_billing_address = self.request.user.billing_addresses.last()
        form_kwargs = super(PaymentVMView, self).get_form_kwargs()
        if not current_billing_address:
            return form_kwargs

        form_kwargs.update({
            'initial': {
                'cardholder_name': current_billing_address.cardholder_name,
                'street_address': current_billing_address.street_address,
                'city': current_billing_address.city,
                'postal_code': current_billing_address.postal_code,
                'country': current_billing_address.country,
                'vat_number': current_billing_address.vat_number
            }
        })
        return form_kwargs

    def get_context_data(self, **kwargs):
        context = super(PaymentVMView, self).get_context_data(**kwargs)
        # Get user
        user = self.request.user
        if hasattr(user, 'stripecustomer'):
            stripe_customer = user.stripecustomer
        else:
            stripe_customer = None
        cards_list = UserCardDetail.get_all_cards_list(
            stripe_customer=stripe_customer
        )
        context.update({
            'stripe_key': settings.STRIPE_API_PUBLIC_KEY,
            'vm_pricing': VMPricing.get_vm_pricing_by_name(
                self.request.session.get('specs', {}).get('pricing_name')
            ),
            'cards_list': cards_list,
        })

        return context

    @method_decorator(decorators)
    def get(self, request, *args, **kwargs):
        if 'next' in request.session:
            del request.session['next']
        HostingUtils.clear_items_from_list(
            request.session,
            ['token', 'card_id', 'customer', 'user']
        )
        return self.render_to_response(self.get_context_data())

    @method_decorator(decorators)
    def post(self, request, *args, **kwargs):
        form = self.get_form()
        if form.is_valid():
            # Get billing address data
            billing_address_data = form.cleaned_data
            token = form.cleaned_data.get('token')
            owner = self.request.user
            if token is '':
                card_id = form.cleaned_data.get('card')
                customer = owner.stripecustomer
                try:
                    user_card_detail = UserCardDetail.objects.get(id=card_id)
                    if not request.user.has_perm(
                            'view_usercarddetail', user_card_detail
                    ):
                        raise UserCardDetail.DoesNotExist(
                            _("{user} does not have permission to access the "
                              "card").format(user=request.user.email)
                        )
                except UserCardDetail.DoesNotExist as e:
                    ex = str(e)
                    logger.error("Card Id: {card_id}, Exception: {ex}".format(
                            card_id=card_id, ex=ex
                        )
                    )
                    msg = _("An error occurred. Details: {}".format(ex))
                    messages.add_message(
                        self.request, messages.ERROR, msg,
                        extra_tags='make_charge_error'
                    )
                    return HttpResponseRedirect(
                        reverse('hosting:payment') + '#payment_error'
                    )
                request.session['card_id'] = user_card_detail.id
            else:
                # Get or create stripe customer
                customer = StripeCustomer.get_or_create(
                    email=owner.email, token=token
                )
                if not customer:
                    msg = _("Invalid credit card")
                    messages.add_message(
                        self.request, messages.ERROR, msg,
                        extra_tags='make_charge_error')
                    return HttpResponseRedirect(
                        reverse('hosting:payment') + '#payment_error')
                request.session['token'] = token
            request.session['billing_address_data'] = billing_address_data
            self.request.session['order_confirm_url'] = "{url}?{query_params}".format(
                    url=reverse('hosting:order-confirmation'),
                    query_params='page=payment')
            return HttpResponseRedirect(reverse('hosting:add_ssh_key'))
        else:
            return self.form_invalid(form)


class OrdersHostingDetailView(LoginRequiredMixin, DetailView, FormView):
    form_class = UserHostingKeyForm
    template_name = "hosting/order_detail.html"
    context_object_name = "order"
    login_url = reverse_lazy('hosting:login')
    permission_required = ['view_hostingorder']
    model = HostingOrder

    def get_form_kwargs(self):
        kwargs = super(OrdersHostingDetailView, self).get_form_kwargs()
        kwargs.update({'request': self.request})
        return kwargs

    def get_object(self, queryset=None):
        order_id = self.kwargs.get('pk')
        try:
            hosting_order_obj = HostingOrder.objects.get(pk=order_id)
            logger.debug("Found HostingOrder for id {order_id}".format(
                order_id=order_id
            ))
        except HostingOrder.DoesNotExist:
            logger.debug("HostingOrder not found for id {order_id}".format(
                order_id=order_id
            ))
            hosting_order_obj = None
        return hosting_order_obj

    def get_context_data(self, **kwargs):
        # Get context
        context = super(
            OrdersHostingDetailView, self
        ).get_context_data(**kwargs)
        obj = self.get_object()
        owner = self.request.user

        if self.request.GET.get('page') == 'payment':
            context['page_header_text'] = _('Confirm Order')
            context['form'] = UserHostingKeyForm(request=self.request)
            context['keys'] = get_all_public_keys(self.request.user)
        else:
            context['page_header_text'] = _('Invoice')
            if not self.request.user.has_perm(
                    self.permission_required[0], obj
            ):
                logger.debug(
                    "User {user} does not have permission on HostingOrder "
                    "{order_id}. Raising 404 error now.".format(
                        user=self.request.user.email,
                        order_id=obj.id if obj else 'None'
                    )
                )
                raise Http404

        if obj is not None:
            if obj.generic_product_id is not None:
                # generic payment case
                logger.debug("Generic payment case")
                context['product_name'] = GenericProduct.objects.get(
                    id=obj.generic_product_id
                ).product_name
            else:
                # invoice for previous order
                logger.debug("Invoice of VM order")
                try:
                    vm_detail = VMDetail.objects.get(vm_id=obj.vm_id)
                    context['vm'] = vm_detail.__dict__
                    context['vm']['name'] = '{}-{}'.format(
                        context['vm']['configuration'], context['vm']['vm_id'])
                    user_vat_country = obj.billing_address.country
                    user_country_vat_rate = get_vat_rate_for_country(
                        user_vat_country)
                    price, vat, vat_percent, discount = get_vm_price_for_given_vat(
                        cpu=context['vm']['cores'],
                        ssd_size=context['vm']['disk_size'],
                        memory=context['vm']['memory'],
                        pricing_name=(obj.vm_pricing.name
                                      if obj.vm_pricing else 'default'),
                        vat_rate= (
                            user_country_vat_rate * 100
                            if obj.vm_id >= settings.FIRST_VM_ID_AFTER_EU_VAT
                            else settings.PRE_EU_VAT_RATE
                        )
                    )
                    context['vm']["after_eu_vat_intro"] = (
                        True if obj.vm_id >= settings.FIRST_VM_ID_AFTER_EU_VAT
                        else False
                    )
                    context['vm']["price"] = price
                    context['vm']["vat"] = vat
                    context['vm']["vat_percent"] = vat_percent
                    context['vm']["vat_country"] = user_vat_country
                    context['vm']["discount"] = discount
                    context['vm']["total_price"] = round(
                        price + vat - discount['amount'], 2)
                    context['subscription_end_date'] = vm_detail.end_date()
                except VMDetail.DoesNotExist:
                    try:
                        manager = OpenNebulaManager(
                            email=owner.username, password=owner.password
                        )
                        vm = manager.get_vm(obj.vm_id)
                        context['vm'] = VirtualMachineSerializer(vm).data
                        user_vat_country = obj.billing_address.country
                        user_country_vat_rate = get_vat_rate_for_country(
                            user_vat_country)
                        price, vat, vat_percent, discount = get_vm_price_for_given_vat(
                            cpu=context['vm']['cores'],
                            ssd_size=context['vm']['disk_size'],
                            memory=context['vm']['memory'],
                            pricing_name=(obj.vm_pricing.name
                                          if obj.vm_pricing else 'default'),
                            vat_rate=(
                                user_country_vat_rate * 100
                                if obj.vm_id >= settings.FIRST_VM_ID_AFTER_EU_VAT
                                else settings.PRE_EU_VAT_RATE
                            )
                        )
                        context['vm']["after_eu_vat_intro"] = (
                            True if obj.vm_id >= settings.FIRST_VM_ID_AFTER_EU_VAT
                            else False
                        )
                        context['vm']["price"] = price
                        context['vm']["vat"] = vat
                        context['vm']["vat_percent"] = vat_percent
                        context['vm']["vat_country"] = user_vat_country
                        context['vm']["discount"] = discount
                        context['vm']["total_price"] = round(
                            price + vat - discount['amount'], 2)
                    except WrongIdError:
                        messages.error(
                            self.request,
                            _('The VM you are looking for is unavailable at the '
                              'moment. Please contact Data Center Light support.')
                        )
                        self.kwargs['error'] = 'WrongIdError'
                        context['error'] = 'WrongIdError'
                    except ConnectionRefusedError:
                        messages.error(
                            self.request,
                            _('In order to create a VM, you need to create/upload '
                              'your SSH KEY first.')
                        )
        else:
            # new order, confirm payment
            if 'token' in self.request.session:
                token = self.request.session['token']
                stripe_utils = StripeUtils()
                card_details = stripe_utils.get_cards_details_from_token(
                    token
                )
                if not card_details.get('response_object'):
                    return HttpResponseRedirect(reverse('hosting:payment'))
                card_details_response = card_details['response_object']
                context['cc_last4'] = card_details_response['last4']
                context['cc_brand'] = card_details_response['brand']
                context['cc_exp_year'] = card_details_response['exp_year']
                context['cc_exp_month'] = card_details_response['exp_month']
            else:
                card_id = self.request.session.get('card_id')
                card_detail = UserCardDetail.objects.get(id=card_id)
                context['cc_last4'] = card_detail.last4
                context['cc_brand'] = card_detail.brand
                context['cc_exp_year'] = card_detail.exp_year
                context['cc_exp_month'] = '{:02d}'.format(card_detail.exp_month)
            context['site_url'] = reverse('hosting:create_virtual_machine')
            vm_specs = self.request.session.get('specs')
            user_vat_country = (
                self.request.session.get('billing_address_data').get("country")
            )
            user_country_vat_rate = get_vat_rate_for_country(user_vat_country)
            price, vat, vat_percent, discount = get_vm_price_for_given_vat(
                cpu=vm_specs['cpu'],
                memory=vm_specs['memory'],
                ssd_size=vm_specs['disk_size'],
                pricing_name=vm_specs['pricing_name'],
                vat_rate=user_country_vat_rate * 100
            )
            vm_specs["price"] = price
            vm_specs["vat"] = vat
            vm_specs["vat_percent"] = vat_percent
            vm_specs["vat_country"] = user_vat_country
            vm_specs["discount"] = discount
            vm_specs["total_price"] = round(price + vat - discount['amount'],
                                            2)
            vm_specs["after_eu_vat_intro"] = True
            context['vm'] = vm_specs
        return context

    @method_decorator(decorators)
    def get(self, request, *args, **kwargs):
        if not self.kwargs.get('pk'):
            if 'specs' not in self.request.session:
                return HttpResponseRedirect(
                    reverse('hosting:create_virtual_machine')
                )

            if ('token' not in self.request.session and
                    'card_id' not in self.request.session):
                return HttpResponseRedirect(reverse('hosting:payment'))
        self.object = self.get_object()
        context = self.get_context_data(object=self.object)
        if 'failed_payment' in context:
            msg = context['card_details'].get('error')
            messages.add_message(
                self.request, messages.ERROR, msg,
                extra_tags='failed_payment'
            )
            return HttpResponseRedirect(
                reverse('hosting:payment') + '#payment_error'
            )
        return self.render_to_response(context)

    @method_decorator(decorators)
    def post(self, request):
        template = request.session.get('template')
        specs = request.session.get('specs')
        stripe_utils = StripeUtils()
        # We assume that if the user is here, his/her StripeCustomer
        # object already exists
        stripe_customer_id = request.user.stripecustomer.id
        billing_address_data = request.session.get('billing_address_data')
        vm_template_id = template.get('id', 1)
        stripe_api_cus_id = request.user.stripecustomer.stripe_id
        logger.debug("template=%s specs=%s stripe_customer_id=%s "
                     "billing_address_data=%s vm_template_id=%s "
                     "stripe_api_cus_id=%s" % (
            template, specs, stripe_customer_id, billing_address_data,
            vm_template_id, stripe_api_cus_id)
        )
        if 'id_payment_method' in self.request.session:
            card_details = stripe_utils.get_cards_details_from_token(
                request.session['token']
            )
            if not card_details.get('response_object'):
                return HttpResponseRedirect(reverse('hosting:payment'))
            card_details_response = card_details['response_object']
            card_details_dict = {
                'last4': card_details_response['last4'],
                'brand': card_details_response['brand'],
                'card_id': card_details_response['card_id']
            }
            ucd = UserCardDetail.get_user_card_details(
                request.user.stripecustomer, card_details_response
            )
            if not ucd:
                acc_result = stripe_utils.associate_customer_card(
                    stripe_api_cus_id, request.session['id_payment_method'],
                    set_as_default=True
                )
                if acc_result['response_object'] is None:
                    msg = _(
                        'An error occurred while associating the card.'
                        ' Details: {details}'.format(
                            details=acc_result['error']
                        )
                    )
                    messages.add_message(self.request, messages.ERROR, msg,
                                         extra_tags='failed_payment')
                    response = {
                        'status': False,
                        'redirect': "{url}#{section}".format(
                            url=reverse('hosting:payment'),
                            section='payment_error'),
                        'msg_title': str(_('Error.')),
                        'msg_body': str(
                            _('There was a payment related error.'
                              ' On close of this popup, you will be redirected'
                              ' back to the payment page.')
                        )
                    }
                    return JsonResponse(response)
        else:
            card_id = request.session.get('card_id')
            user_card_detail = UserCardDetail.objects.get(id=card_id)
            card_details_dict = {
                'last4': user_card_detail.last4,
                'brand': user_card_detail.brand,
                'card_id': user_card_detail.card_id
            }
            if not user_card_detail.preferred:
                UserCardDetail.set_default_card(
                    stripe_api_cus_id=stripe_api_cus_id,
                    stripe_source_id=user_card_detail.card_id
                )
        cpu = specs.get('cpu')
        memory = specs.get('memory')
        disk_size = specs.get('disk_size')
        amount_to_be_charged = specs.get('price')
        discount = specs.get('discount')
        plan_name = StripeUtils.get_stripe_plan_name(
            cpu=cpu,
            memory=memory,
            disk_size=disk_size,
            price=amount_to_be_charged
        )
        stripe_plan_id = StripeUtils.get_stripe_plan_id(
            cpu=cpu,
            ram=memory,
            ssd=disk_size,
            version=1,
            app='dcl',
            price=amount_to_be_charged
        )
        stripe_plan = stripe_utils.get_or_create_stripe_plan(
            amount=amount_to_be_charged,
            name=plan_name,
            stripe_plan_id=stripe_plan_id)
        # Create StripeTaxRate if applicable to the user
        stripe_tax_rate = None
        if specs["vat_percent"] > 0:
            try:
                stripe_tax_rate = StripeTaxRate.objects.get(
                    description="VAT for %s" % specs["vat_country"]
                )
                print("Stripe Tax Rate exists")
            except StripeTaxRate.DoesNotExist as dne:
                print("StripeTaxRate does not exist")
                tax_rate_obj = stripe.TaxRate.create(
                    display_name="VAT",
                    description="VAT for %s" % specs["vat_country"],
                    jurisdiction=specs["vat_country"],
                    percentage=specs["vat_percent"] * 100,
                    inclusive=False,
                )
                stripe_tax_rate = StripeTaxRate.objects.create(
                    display_name=tax_rate_obj.display_name,
                    description=tax_rate_obj.description,
                    jurisdiction=tax_rate_obj.jurisdiction,
                    percentage=tax_rate_obj.percentage,
                    inclusive=False,
                    tax_rate_id=tax_rate_obj.id
                )
                logger.debug("Created StripeTaxRate %s" %
                             stripe_tax_rate.tax_rate_id)
        subscription_result = stripe_utils.subscribe_customer_to_plan(
            stripe_api_cus_id,
            [{"plan": stripe_plan.get('response_object').stripe_plan_id}],
            coupon=(discount['stripe_coupon_id']
                    if 'name' in discount and
                       discount['name'] is not None and
                       'ipv6' in discount['name'].lower() and
                       discount['stripe_coupon_id']
                    else ""),
            tax_rates=[stripe_tax_rate.tax_rate_id] if stripe_tax_rate else [],
            default_payment_method=request.session['id_payment_method']
        )
        stripe_subscription_obj = subscription_result.get('response_object')
        latest_invoice = stripe.Invoice.retrieve(stripe_subscription_obj.latest_invoice)
        ret = stripe.PaymentIntent.confirm(
            latest_invoice.payment_intent
        )
        if ret.status == 'requires_source_action' or ret.status == 'requires_action':
            pi = stripe.PaymentIntent.retrieve(
                latest_invoice.payment_intent
            )
            context = {
                'sid': stripe_subscription_obj.id,
                'payment_intent_secret': pi.client_secret,
                'STRIPE_PUBLISHABLE_KEY': settings.STRIPE_API_PUBLIC_KEY,
                'showSCA': True
            }
            return JsonResponse(context)
        # Check if the subscription was approved and is active
        if (stripe_subscription_obj is None or
                stripe_subscription_obj.status != 'active'):
            # At this point, we have created a Stripe API card and
            # associated it with the customer; but the transaction failed
            # due to some reason. So, we would want to dissociate this card
            # here.
            # ...

            msg = subscription_result.get('error')
            messages.add_message(self.request, messages.ERROR, msg,
                                 extra_tags='failed_payment')
            response = {
                'status': False,
                'redirect': "{url}#{section}".format(
                    url=reverse('hosting:payment'),
                    section='payment_error'),
                'msg_title': str(_('Error.')),
                'msg_body': str(
                    _('There was a payment related error.'
                      ' On close of this popup, you will be redirected back to'
                      ' the payment page.')
                )
            }
            return JsonResponse(response)

        if 'token' in request.session:
            ucd = UserCardDetail.get_or_create_user_card_detail(
                stripe_customer=self.request.user.stripecustomer,
                card_details=card_details_response
            )
            UserCardDetail.save_default_card_local(
                self.request.user.stripecustomer.stripe_id,
                ucd.card_id
            )
        user = {
            'name': self.request.user.name,
            'email': self.request.user.email,
            'username': self.request.user.username,
            'pass': self.request.user.password,
            'request_scheme': request.scheme,
            'request_host': request.get_host(),
            'language': get_language(),
        }

        create_vm(
            billing_address_data, stripe_customer_id, specs,
            stripe_subscription_obj, card_details_dict, request,
            vm_template_id, template, user
        )

        response = {
            'status': True,
            'redirect': reverse('hosting:virtual_machines'),
            'msg_title': str(_('Thank you for the order.')),
            'msg_body': str(
                _('Your VM will be up and running in a few moments.'
                  ' We will send you a confirmation email as soon as'
                  ' it is ready.'))
        }

        return JsonResponse(response)


class OrdersHostingListView(LoginRequiredMixin, ListView):
    template_name = "hosting/orders.html"
    login_url = reverse_lazy('hosting:login')
    context_object_name = "orders"
    model = HostingOrder
    paginate_by = 10
    ordering = '-id'

    def get_queryset(self):
        user = self.request.user
        self.queryset = HostingOrder.objects.filter(customer__user=user)
        return super(OrdersHostingListView, self).get_queryset()

    @method_decorator(decorators)
    def get(self, request, *args, **kwargs):
        return super(OrdersHostingListView, self).get(request, *args, **kwargs)


class InvoiceListView(LoginRequiredMixin, TemplateView):
    template_name = "hosting/invoices.html"
    login_url = reverse_lazy('hosting:login')
    context_object_name = "invoices"
    paginate_by = 10
    ordering = '-created'

    def get_context_data(self, **kwargs):
        page = self.request.GET.get('page', 1)
        context = super(InvoiceListView, self).get_context_data(**kwargs)
        invs_page = None
        invs_page_charges = None
        if ('user_email' in self.request.GET
            and self.request.user.email == settings.ADMIN_EMAIL):
            user_email = self.request.GET['user_email']
            context['user_email'] = '%s' % quote(user_email)
            logger.debug(
                "user_email = {}".format(user_email)
            )
            try:
                cu = CustomUser.objects.get(email=user_email)
            except CustomUser.DoesNotExist as dne:
                logger.debug("User does not exist")
                cu = self.request.user
            invs = stripe.Invoice.list(customer=cu.stripecustomer.stripe_id,
                                       count=100,
                                       status='paid')
            paginator = Paginator(invs.data, 10)
            try:
                invs_page = paginator.page(page)
            except PageNotAnInteger:
                invs_page = paginator.page(1)
            except EmptyPage:
                invs_page = paginator.page(paginator.num_pages)
            hosting_orders = HostingOrder.objects.filter(
                customer=cu.stripecustomer).filter(
                Q(subscription_id=None) | Q(subscription_id='')
            ).order_by('-created_at')
            stripe_chgs = []
            for ho in hosting_orders:
                stripe_chgs.append({ho.id: stripe.Charge.retrieve(ho.stripe_charge_id)})

            paginator_charges = Paginator(stripe_chgs, 10)
            try:
                invs_page_charges = paginator_charges.page(page)
            except PageNotAnInteger:
                invs_page_charges = paginator_charges.page(1)
            except EmptyPage:
                invs_page_charges = paginator_charges.page(paginator_charges.num_pages)
        else:
            try:
                invs = stripe.Invoice.list(
                    customer=self.request.user.stripecustomer.stripe_id,
                    count=100
                )
                paginator = Paginator(invs.data, 10)
                try:
                    invs_page = paginator.page(page)
                except PageNotAnInteger:
                    invs_page = paginator.page(1)
                except EmptyPage:
                    invs_page = paginator.page(paginator.num_pages)
                hosting_orders = HostingOrder.objects.filter(
                    customer=self.request.user.stripecustomer).filter(
                    Q(subscription_id=None) | Q(subscription_id='')
                ).order_by('-created_at')
                stripe_chgs = []
                for ho in hosting_orders:
                    stripe_chgs.append(
                        {ho: stripe.Charge.retrieve(ho.stripe_charge_id)})
                paginator_charges = Paginator(stripe_chgs, 10)
                try:
                    invs_page_charges = paginator_charges.page(page)
                except PageNotAnInteger:
                    invs_page_charges = paginator_charges.page(1)
                except EmptyPage:
                    invs_page_charges = paginator_charges.page(
                        paginator_charges.num_pages)
            except Exception as ex:
                logger.error(str(ex))
                invs_page = None
        context["invs"] = invs_page
        context["invs_charge"] = invs_page_charges
        return context

    @method_decorator(decorators)
    def get(self, request, *args, **kwargs):
        return super(InvoiceListView, self).get(request, *args, **kwargs)


class InvoiceDetailView(LoginRequiredMixin, DetailView):
    template_name = "hosting/invoice_detail.html"
    context_object_name = "invoice"
    login_url = reverse_lazy('hosting:login')
    permission_required = ['view_monthlyhostingbill']
    # model = MonthlyHostingBill

    def get_object(self, queryset=None):
        invoice_id = self.kwargs.get('invoice_id')
        try:
            invoice_obj = MonthlyHostingBill.objects.get(
                invoice_number=invoice_id
            )
            logger.debug("Found MHB for id {invoice_id}".format(
                invoice_id=invoice_id
            ))
            if self.request.user.has_perm(
                    self.permission_required[0], invoice_obj
            ) or self.request.user.email == settings.ADMIN_EMAIL:
                logger.debug("User has permission to invoice_obj")
            else:
                logger.error("User does not have permission to access")
                invoice_obj = None
        except MonthlyHostingBill.DoesNotExist as dne:
            logger.debug("MHB not found for id {invoice_id}".format(
                invoice_id=invoice_id
            ))
            invoice_obj = None
        return invoice_obj

    def get_context_data(self, **kwargs):
        # Get context
        context = super(InvoiceDetailView, self).get_context_data(**kwargs)
        obj = self.get_object()

        if obj is not None:
            vm_id = obj.get_vm_id()
            try:
                # Try to get vm details from database
                vm_detail = VMDetail.objects.get(vm_id=vm_id)
                context['vm'] = vm_detail.__dict__
                context['vm']['name'] = '{}-{}'.format(
                    context['vm']['configuration'], context['vm']['vm_id'])
                user_vat_country = obj.order.billing_address.country
                user_country_vat_rate = get_vat_rate_for_country(
                    user_vat_country)
                price, vat, vat_percent, discount = get_vm_price_for_given_vat(
                    cpu=context['vm']['cores'],
                    ssd_size=context['vm']['disk_size'],
                    memory=context['vm']['memory'],
                    pricing_name=(obj.order.vm_pricing.name
                                  if obj.order.vm_pricing else 'default'),
                    vat_rate=(
                        user_country_vat_rate * 100
                        if obj.order.vm_id >= settings.FIRST_VM_ID_AFTER_EU_VAT
                        else settings.PRE_EU_VAT_RATE
                    )
                )
                context['vm']["after_eu_vat_intro"] = (
                    True if obj.order.vm_id >= settings.FIRST_VM_ID_AFTER_EU_VAT
                    else False
                )
                context['vm']["price"] = price
                context['vm']["vat"] = vat
                context['vm']["vat_percent"] = vat_percent
                context['vm']["vat_country"] = user_vat_country
                context['vm']["discount"] = discount
                context['vm']["total_price"] = round(
                    price + vat - discount['amount'], 2)
            except VMDetail.DoesNotExist:
                # fallback to get it from the infrastructure
                try:
                    manager = OpenNebulaManager(
                        email=self.request.user.username,
                        password=self.request.user.password
                    )
                    vm = manager.get_vm(vm_id)
                    context['vm'] = VirtualMachineSerializer(vm).data
                    user_vat_country = obj.order.billing_address.country
                    user_country_vat_rate = get_vat_rate_for_country(
                        user_vat_country)
                    price, vat, vat_percent, discount = get_vm_price_for_given_vat(
                        cpu=context['vm']['cores'],
                        ssd_size=context['vm']['disk_size'],
                        memory=context['vm']['memory'],
                        pricing_name=(obj.order.vm_pricing.name
                                      if obj.order.vm_pricing else 'default'),
                        vat_rate=(
                            user_country_vat_rate * 100
                            if obj.order.vm_id >= settings.FIRST_VM_ID_AFTER_EU_VAT
                            else settings.PRE_EU_VAT_RATE
                        )
                    )
                    context['vm']["after_eu_vat_intro"] = (
                        True if obj.order.vm_id >= settings.FIRST_VM_ID_AFTER_EU_VAT
                        else False
                    )
                    context['vm']["price"] = price
                    context['vm']["vat"] = vat
                    context['vm']["vat_percent"] = vat_percent
                    context['vm']["vat_country"] = user_vat_country
                    context['vm']["discount"] = discount
                    context['vm']["total_price"] = round(
                        price + vat - discount['amount'], 2)
                except TypeError:
                    logger.error("Type error. Probably we "
                                 "came from a generic product. "
                                 "Invoice ID %s" % obj.invoice_id)
                except WrongIdError:
                    logger.error("WrongIdError while accessing "
                                 "invoice {}".format(obj.invoice_id))
                    messages.error(
                        self.request,
                        _('The VM you are looking for is unavailable at the '
                          'moment. Please contact Data Center Light support.')
                    )
                    self.kwargs['error'] = 'WrongIdError'
                    context['error'] = 'WrongIdError'
                    return context

            # add context params from monthly hosting bill
            context['period_start'] = obj.get_period_start()
            context['period_end'] = obj.get_period_end()
            context['paid_at'] = obj.paid_at
            context['total_in_chf'] = obj.total_in_chf()
            context['invoice_number'] = obj.invoice_number
            context['discount_on_stripe'] = obj.discount_in_chf()
            if obj.lines_data_count > 1:
                # special case, we pass the details of each of the line items
                context['line_items'] = obj.hostingbilllineitem_set.all()
            return context
        else:
            raise Http404

    @method_decorator(decorators)
    def get(self, request, *args, **kwargs):
        self.object = self.get_object()
        context = self.get_context_data(object=self.get_object())
        return self.render_to_response(context)


class OrdersHostingDeleteView(LoginRequiredMixin, DeleteView):
    login_url = reverse_lazy('hosting:login')
    success_url = reverse_lazy('hosting:orders')
    model = HostingOrder


class VirtualMachinesPlanListView(LoginRequiredMixin, ListView):
    template_name = "hosting/virtual_machines.html"
    login_url = reverse_lazy('hosting:login')
    context_object_name = "vms"
    paginate_by = 10
    ordering = '-id'

    def get_queryset(self):
        owner = self.request.user
        manager = OpenNebulaManager(email=owner.username,
                                    password=owner.password)
        try:
            queryset = manager.get_vms()
            serializer = VirtualMachineSerializer(queryset, many=True)
            return serializer.data
        except ConnectionRefusedError:
            messages.error(self.request,
                           'We could not load your VMs due to a backend connection \
                error. Please try again in a few minutes'
                           )

            self.kwargs['error'] = 'connection'
            return []

    def get_context_data(self, **kwargs):
        error = self.kwargs.get('error')
        if error is not None:
            print(error)
            context = {'error': 'connection'}
        else:
            context = super(ListView, self).get_context_data(**kwargs)
            if UserHostingKey.objects.filter(user=self.request.user).exists():
                context['show_create_ssh_key_msg'] = False
            else:
                context['show_create_ssh_key_msg'] = True
        return context


class CreateVirtualMachinesView(LoginRequiredMixin, View):
    template_name = "hosting/create_virtual_machine.html"
    login_url = reverse_lazy('hosting:login')

    def validate_cores(self, value):
        if (value > 48) or (value < 1):
            raise ValidationError(_('Invalid number of cores'))

    def validate_memory(self, value):
        if 'pid' in self.request.POST:
            try:
                plugin = DCLCalculatorPluginModel.objects.get(
                             id=self.request.POST['pid']
                         )
            except DCLCalculatorPluginModel.DoesNotExist as dne:
                logger.error(
                    str(dne) + " plugin_id: " + self.request.POST['pid']
                )
                raise ValidationError(_('Invalid calculator properties'))
            if plugin.enable_512mb_ram:
                if value % 1 == 0 or value == 0.5:
                    logger.debug(
                        "Given ram {value} is either 0.5 or a"
                        " whole number".format(value=value)
                    )
                    if (value > 200) or (value < 0.5):
                        raise ValidationError(_('Invalid RAM size'))
                else:
                    raise ValidationError(_('Invalid RAM size'))
            elif (value > 200) or (value < 1) or (value % 1 != 0):
                raise ValidationError(_('Invalid RAM size'))
        else:
            raise ValidationError(_('Invalid RAM size'))

    def validate_storage(self, value):
        if (value > 2000) or (value < 10):
            raise ValidationError(_('Invalid storage size'))

    @method_decorator(decorators)
    def get(self, request, *args, **kwargs):
        context = {
            'templates': VMTemplate.objects.all(),
            'cms_integration': get_cms_integration('default'),
        }
        return render(request, self.template_name, context)

    @method_decorator(decorators)
    def post(self, request):
        cores = request.POST.get('cpu')
        cores_field = forms.IntegerField(validators=[self.validate_cores])
        memory = request.POST.get('ram')
        memory_field = forms.FloatField(validators=[self.validate_memory])
        storage = request.POST.get('storage')
        storage_field = forms.IntegerField(validators=[self.validate_storage])
        template_id = int(request.POST.get('config'))
        pricing_name = request.POST.get('pricing_name')
        vm_pricing = VMPricing.get_vm_pricing_by_name(pricing_name)
        template = VMTemplate.objects.filter(
            opennebula_vm_template_id=template_id).first()
        template_data = VMTemplateSerializer(template).data

        if vm_pricing is None:
            vm_pricing_name_msg = _(
                "Incorrect pricing name. Please contact support"
                "{support_email}".format(
                    support_email=settings.DCL_SUPPORT_FROM_ADDRESS
                )
            )
            messages.add_message(
                self.request, messages.ERROR, vm_pricing_name_msg,
                extra_tags='pricing'
            )
            return redirect(CreateVirtualMachinesView.as_view())
        else:
            vm_pricing_name = vm_pricing.name

        try:
            cores = cores_field.clean(cores)
        except ValidationError as err:
            msg = '{} : {}.'.format(cores, str(err))
            messages.add_message(self.request, messages.ERROR, msg,
                                 extra_tags='cores')
            return redirect(CreateVirtualMachinesView.as_view())

        try:
            memory = memory_field.clean(memory)
        except ValidationError as err:
            msg = '{} : {}.'.format(memory, str(err))
            messages.add_message(self.request, messages.ERROR, msg,
                                 extra_tags='memory')
            return redirect(CreateVirtualMachinesView.as_view())

        try:
            storage = storage_field.clean(storage)
        except ValidationError as err:
            msg = '{} : {}.'.format(storage, str(err))
            messages.add_message(self.request, messages.ERROR, msg,
                                 extra_tags='storage')
            return redirect(CreateVirtualMachinesView.as_view())

        price, vat, vat_percent, discount = get_vm_price_with_vat(
            cpu=cores,
            memory=memory,
            ssd_size=storage,
            pricing_name=vm_pricing_name
        )

        specs = {
            'cpu': cores,
            'memory': memory,
            'disk_size': storage,
            'discount': discount,
            'price': price,
            'vat': vat,
            'vat_percent': vat_percent,
            'total_price': round(price + vat - discount['amount'], 2),
            'pricing_name': vm_pricing_name
        }

        request.session['specs'] = specs
        request.session['template'] = template_data
        return redirect(reverse('hosting:payment'))


class VirtualMachineView(LoginRequiredMixin, View):
    template_name = "hosting/virtual_machine_detail.html"
    login_url = reverse_lazy('hosting:login')

    def get_object(self):
        username = self.request.GET.get('username')
        if self.request.user.is_admin and username:
            owner = CustomUser.objects.get(username=username)
        else:
            owner = self.request.user
        vm = None
        manager = OpenNebulaManager(
            email=owner.username,
            password=owner.password
        )
        vm_id = self.kwargs.get('pk')
        try:
            vm = manager.get_vm(vm_id)
            return vm
        except WrongIdError:
            messages.error(self.request,
                           _('We could not find the requested VM. Please \
                           contact Data Center Light Support.')
                           )
            return None
        except ConnectionRefusedError:
            messages.error(self.request,
                           'We could not load your VM due to a backend connection \
                error. Please try again in a few minutes'
                           )
            return None
        except Exception as error:
            logger.error(str(error))
            raise Http404()

    def get_success_url(self):
        final_url = reverse('hosting:virtual_machines')
        return final_url

    @method_decorator(decorators)
    def get(self, request, *args, **kwargs):
        vm = self.get_object()
        if vm is None:
            if self.request.is_ajax():
                storage = messages.get_messages(request)
                for m in storage:
                    pass
                storage.used = True
                return JsonResponse({'text': ugettext('Terminated')})
            else:
                return redirect(reverse('hosting:virtual_machines'))
        elif self.request.is_ajax():
            return HttpResponse()
        context = None
        try:
            serializer = VirtualMachineSerializer(vm)
            hosting_order = HostingOrder.objects.get(
                vm_id=serializer.data['vm_id']
            )
            inv_url = None
            if hosting_order.subscription_id:
                stripe_obj = stripe.Invoice.list(
                   subscription=hosting_order.subscription_id,
                   count=1
                )
                if stripe_obj.data:
                    inv_url = stripe_obj.data[0].hosted_invoice_url
                else:
                    inv_url = ''
            elif hosting_order.stripe_charge_id:
                stripe_obj = stripe.Charge.retrieve(
                    hosting_order.stripe_charge_id
                )
                inv_url = stripe_obj.receipt_url
            context = {
                'virtual_machine': serializer.data,
                'order': hosting_order,
                'keys': UserHostingKey.objects.filter(user=request.user),
                'inv_url': inv_url
            }

        except Exception as ex:
            logger.debug("Exception generated {}".format(str(ex)))
            messages.error(self.request,
                           _('We could not find the requested VM. Please '
                             'contact Data Center Light Support.')
                           )
            return redirect(reverse('hosting:virtual_machines'))

        return render(request, self.template_name, context)

    @method_decorator(decorators)
    def post(self, request, *args, **kwargs):
        response = {'status': False}
        admin_email_body = {}
        owner = self.request.user
        vm = self.get_object()

        manager = OpenNebulaManager(
            email=owner.username,
            password=owner.password
        )
        try:
            vm_data = VirtualMachineSerializer(manager.get_vm(vm.id)).data
            vm_name = vm_data.get('name')
        except WrongIdError as wrong_id_err:
            logger.error(str(wrong_id_err))
            return redirect(reverse('hosting:virtual_machines'))

        # Cancel Stripe subscription
        stripe_utils = StripeUtils()
        hosting_order = None
        stripe_subscription_obj = None
        try:
            hosting_order = HostingOrder.objects.get(
                vm_id=vm.id
            )
            result = stripe_utils.unsubscribe_customer(
                subscription_id=hosting_order.subscription_id
            )
            stripe_subscription_obj = result.get('response_object')
            # Check if the subscription was canceled
            if (stripe_subscription_obj is None or
                    stripe_subscription_obj.status != 'canceled'):
                error_msg = result.get('error')
                logger.error(
                    'Error canceling subscription for {user} and vm id '
                    '{vm_id}'.format(user=owner.username, vm_id=vm.id)
                )
                logger.error(error_msg)
                admin_email_body['stripe_error_msg'] = error_msg
        except HostingOrder.DoesNotExist:
            error_msg = (
                "HostingOrder corresponding to vm_id={vm_id} does"
                "not exist. Hence, can not find subscription to "
                "cancel ".format(vm_id=vm.id)
            )
            logger.error(error_msg)
            admin_email_body['stripe_error_msg'] = error_msg

        terminated = manager.delete_vm(vm.id)

        if not terminated:
            logger.error(
                "manager.delete_vm returned False. Hence, error making "
                "xml-rpc call to delete vm failed."
            )
            response['text'] = str(_('Error terminating VM')) + str(vm.id)
        else:
            for t in range(settings.MAX_TIME_TO_WAIT_FOR_VM_TERMINATE):
                try:
                    manager.get_vm(vm.id)
                except WrongIdError:
                    logger.error(
                        "VM {} not found. So, its terminated.".format(vm.id)
                    )
                    response['status'] = True
                    response['text'] = ugettext('Terminated')
                    vm_detail_obj = VMDetail.objects.filter(
                        vm_id=vm.id
                    ).first()
                    vm_detail_obj.terminated_at = datetime.utcnow()
                    vm_detail_obj.save()
                except BaseException as base_exception:
                    logger.error(
                        "manager.get_vm({vm_id}) returned exception: "
                        "{details}.".format(
                            details=str(base_exception), vm_id=vm.id
                        )
                    )
                    break
                else:
                    logger.debug(
                        'Sleeping 2 seconds for terminate action on VM %s' %
                        vm.id
                    )
                    sleep(2)
            if not response['status']:
                response['text'] = str(_("VM terminate action timed out. "
                                         "Please contact "
                                         "support@datacenterlight.ch for "
                                         "further information."))
            context = {
                'vm_name': vm_name,
                'base_url': "{0}://{1}".format(
                    self.request.scheme, self.request.get_host()
                ),
                'page_header': _('Virtual Machine %(vm_name)s Cancelled') % {
                    'vm_name': vm_name
                }
            }
            email_data = {
                'subject': context['page_header'],
                'to': self.request.user.email,
                'context': context,
                'template_name': 'vm_canceled',
                'template_path': 'hosting/emails/',
                'from_address': settings.DCL_SUPPORT_FROM_ADDRESS,
            }
            email = BaseEmail(**email_data)
            email.send()
        admin_email_body.update(response)
        admin_email_body["customer_email"] = owner.email
        admin_email_body["customer_username"] = owner.username
        admin_email_body["VM_ID"] = vm.id
        admin_email_body["VM_created_at"] = (str(hosting_order.created_at) if
                                             hosting_order is not None
                                             else "unknown")
        content = ""
        total_amount = 0
        if stripe_subscription_obj:
            for line_item in stripe_subscription_obj["items"]["data"]:
                total_amount += (line_item["quantity"] *
                                 line_item.plan["amount"])
                content += "   %s => %s x %s => %s\n" % (
                    line_item.plan["name"], line_item["quantity"],
                    line_item.plan["amount"]/100,
                    (line_item["quantity"] * line_item.plan["amount"])/100
                )
        admin_email_body["subscription_amount"] = total_amount/100
        admin_email_body["subscription_detail"] = content
        admin_msg_sub = "VM and Subscription for VM {} and user: {}, {}".format(
            vm.id,
            owner.email, owner.username
        )
        email_to_admin_data = {
            'subject': ("Deleted " if response['status']
                        else "ERROR deleting ") + admin_msg_sub,
            'from_email': settings.DCL_SUPPORT_FROM_ADDRESS,
            'to': ['dcl-orders@ungleich.ch'],
            'body': "\n".join(
                ["%s=%s" % (k, v) for (k, v) in admin_email_body.items()]),
        }
        send_plain_email_task.delay(email_to_admin_data)
        return JsonResponse(response)


class HostingBillListView(PermissionRequiredMixin, LoginRequiredMixin,
                          ListView):
    template_name = "hosting/bills.html"
    login_url = reverse_lazy('hosting:login')
    permission_required = ['view_hostingview']
    context_object_name = "users"
    model = StripeCustomer
    paginate_by = 10
    ordering = '-id'


class HostingBillDetailView(PermissionRequiredMixin, LoginRequiredMixin,
                            DetailView):
    template_name = "hosting/bill_detail.html"
    login_url = reverse_lazy('hosting:login')
    permission_required = ['view_hostingview']
    context_object_name = "bill"
    model = HostingBill

    def get_object(self, queryset=None):
        # Get HostingBill for primary key (Select from customer users)
        pk = self.kwargs['pk']
        object = HostingBill.objects.filter(customer__id=pk).first()
        if object is None:
            self.template_name = 'hosting/bill_error.html'
        return object

    def get_context_data(self, **kwargs):
        # Get context
        context = super(DetailView, self).get_context_data(**kwargs)

        owner = self.request.user
        manager = OpenNebulaManager(email=owner.username,
                                    password=owner.password)
        # Get vms
        queryset = manager.get_vms()
        vms = VirtualMachineSerializer(queryset, many=True).data
        # Set total price
        bill = context['bill']
        bill.total_price = 0.0
        for vm in vms:
            bill.total_price += vm['price']
        context['vms'] = vms
        return context


def forbidden_view(request, exception=None, reason=''):
    """
    Handle 403 error
    """
    logger.error(str(exception) if exception else None)
    logger.error('Reason = {reason}'.format(reason=reason))
    err_msg = _('There was an error processing your request. Please try '
                'again.')
    messages.add_message(request, messages.ERROR, err_msg)
    return HttpResponseRedirect(request.get_full_path())


class CheckUserVM(APIView):
    renderer_classes = (JSONRenderer, )

    def get(self, request):
        try:
            email = request.data['email']
            ip = request.data['ip']
            user = request.data['user']
            realm = request.data['realm']
            token = request.data['token']
            if realm != settings.READ_VM_REALM:
                return Response("User not allowed", 403)
            response = check_otp(user, realm, token)
            if response != 200:
                return Response('Invalid token', 403)
            manager = OpenNebulaManager(settings.OPENNEBULA_USERNAME,
                                        settings.OPENNEBULA_PASSWORD)
            # not the best way to lookup vms by ip
            # TODO: make this optimal
            vms = manager.get_vms()
            users_vms = [vm for vm in vms if vm.uname == email]
            if len(users_vms) == 0:
                return Response('No VM found with the given email address',
                                404)
            for vm in users_vms:
                for nic in vm.template.nics:
                    if hasattr(nic, 'ip6_global'):
                        if nic.ip6_global == ip:
                            return Response('success', 200)
                    elif hasattr(nic, 'ip'):
                        if nic.ip == ip:
                            return Response('success', 200)
            return Response('No VM found matching the ip address provided', 404)
        except KeyError:
            return Response('Not enough data provided', 400)