import os
from collections import OrderedDict

from django.db import models
from django.utils.functional import cached_property
from django.utils.translation import ugettext_lazy as _
from jsonfield import JSONField

from orchestra.core import validators
from orchestra.utils.functional import cached

from . import settings
from .fields import VirtualDatabaseRelation, VirtualDatabaseUserRelation
from .options import AppOption
from .types import AppType


class WebApp(models.Model):
    """ Represents a web application """
    name = models.CharField(_("name"), max_length=128, validators=[validators.validate_name],
        help_text=_("The app will be installed in %s") % settings.WEBAPPS_BASE_DIR)
    type = models.CharField(_("type"), max_length=32, choices=AppType.get_choices())
    account = models.ForeignKey('accounts.Account', verbose_name=_("Account"),
        related_name='webapps')
    data = JSONField(_("data"), blank=True, default={},
        help_text=_("Extra information dependent of each service."))
    
    # CMS webapps usually need a database and dbuser, with these virtual fields we tell the ORM to delete them
    databases = VirtualDatabaseRelation('databases.Database')
    databaseusers = VirtualDatabaseUserRelation('databases.DatabaseUser')
    
    class Meta:
        unique_together = ('name', 'account')
        verbose_name = _("Web App")
        verbose_name_plural = _("Web Apps")
    
    def __str__(self):
        return self.name
    
    def get_description(self):
        return self.get_type_display()
    
    @cached_property
    def type_class(self):
        return AppType.get(self.type)
    
    @cached_property
    def type_instance(self):
        """ Per request lived type_instance """
        return self.type_class(self)
    
    def clean(self):
        apptype = self.type_instance
        apptype.validate()
        a = apptype.clean_data()
        self.data = apptype.clean_data()
    
    @cached
    def get_options(self, **kwargs):
        options = OrderedDict()
        if not kwargs:
            kwargs = {
                'webapp_id': self.pk,
            }
        qs = WebAppOption.objects.filter(**kwargs)
        for name, value in qs.values_list('name', 'value').order_by('name'):
            if name in options:
                options[name] = max(options[name], value)
            else:
                options[name] = value
        return options
    
    def get_directive(self):
        return self.type_instance.get_directive()
    
    def get_path(self):
        context = {
            'home': self.get_user().get_home(),
            'app_name': self.name,
        }
        path = settings.WEBAPPS_BASE_DIR % context
        public_root = self.options.filter(name='public-root').first()
        if public_root:
            path = os.path.join(path, public_root.value)
        return os.path.normpath(path.replace('//', '/'))
    
    def get_user(self):
        return self.account.main_systemuser
    
    def get_username(self):
        return self.get_user().username
    
    def get_groupname(self):
        return self.get_username()


class WebAppOption(models.Model):
    webapp = models.ForeignKey(WebApp, verbose_name=_("Web application"),
        related_name='options')
    name = models.CharField(_("name"), max_length=128, choices=AppType.get_options_choices())
    value = models.CharField(_("value"), max_length=256)
    
    class Meta:
        unique_together = ('webapp', 'name')
        verbose_name = _("option")
        verbose_name_plural = _("options")
    
    def __str__(self):
        return self.name
    
    @cached_property
    def option_class(self):
        return AppOption.get(self.name)
    
    @cached_property
    def option_instance(self):
        """ Per request lived option instance """
        return self.option_class(self)
    
    def clean(self):
        self.option_instance.validate()