"""
This module contains models related to domain names.

"""
from __future__ import absolute_import, unicode_literals

from django.db import models, transaction
from django.conf import settings
from django.utils.encoding import python_2_unicode_compatible
from django.utils.translation import ugettext as _

from model_utils.models import TimeStampedModel
from model_utils import Choices


DNS_DOMAIN_TYPES = Choices(
    ('MASTER', _('Master')),
    ('SLAVE', _('Slave')),
    ('NATIVE', _('Native')),
)

# see https://doc.powerdns.com/md/authoritative/domainmetadata/
DNS_DOMAIN_METADATA_KINDS = Choices(
    'ALLOW-DNSUPDATE-FROM',
    'ALSO-NOTIFY',
    'AXFR-MASTER-TSIG',
    'AXFR-SOURCE',
    'FORWARD-DNSUPDATE',
    'GSS-ACCEPTOR-PRINCIPAL',
    'GSS-ALLOW-AXFR-PRINCIPAL',
    'LUA-AXFR-SCRIPT',
    'NSEC3NARROW',
    'NSEC3PARAM',
    'PRESIGNED',
    'PUBLISH_CDNSKEY',
    'PUBLISH_CDS',
    'SOA-EDIT',
    'SOA-EDIT-DNSUPDATE',
    'TSIG-ALLOW-AXFR',
    'TSIG-ALLOW-DNSUPDATE',
)

DNS_TSIG_KEY_ALGORITHMS = Choices(
    ('hmac-md5', _('HMAC MD5')),
    ('hmac-sha1', _('HMAC SHA1')),
    ('hmac-sha224', _('HMAC SHA224')),
    ('hmac-sha256', _('HMAC SHA256')),
    ('hmac-sha384', _('HMAC SHA384')),
    ('hmac-sha512', _('HMAC SHA512')),
)


@python_2_unicode_compatible
class DomainBase(TimeStampedModel):
    """
    This is the base model for domains.

    """
    domain = models.CharField(_('domain name'), max_length=255, unique=True)
    customer = models.ForeignKey(
        settings.AUTH_USER_MODEL, verbose_name=_('customer'), blank=True,
        null=True)

    class Meta:
        abstract = True

    def __str__(self):
        return self.domain


@python_2_unicode_compatible
class MailDomain(DomainBase):
    """
    This is the model for mail domains. Mail domains are used to configure the
    mail servers (SMTP/IMAP/POP3). Mail addresses are assigned to these mail
    domains.

    """
    class Meta:
        verbose_name = _('Mail domain')
        verbose_name_plural = _('Mail domains')

    def __str__(self):
        return self.domain

    def get_mailaddresses(self):
        """
        Get a list of mail addresses assigned to this mail domain.

        """
        return self.mailaddress_set.all()
    mailaddresses = property(get_mailaddresses)


class HostingDomainManager(models.Manager):
    """
    Default Manager for :py:class:`HostingDomain`.

    """
    @transaction.atomic
    def create_for_hosting_package(
        self, hosting_package, domain, commit, **kwargs
    ):
        from hostingpackages.models import CustomerHostingPackageDomain
        hostingdomain = self.create(
            customer=hosting_package.customer, domain=domain, **kwargs)
        hostingdomain.maildomain = MailDomain.objects.create(
            customer=hosting_package.customer, domain=domain)
        custdomain = CustomerHostingPackageDomain.objects.create(
            hosting_package=hosting_package, domain=hostingdomain)
        if commit:
            hostingdomain.save()
            custdomain.save()
        return hostingdomain


@python_2_unicode_compatible
class HostingDomain(DomainBase):
    """
    This is the model for hosting domains. A hosting domain is linked to a
    customer hosting account.

    """
    maildomain = models.OneToOneField(
        MailDomain, verbose_name=_('mail domain'), blank=True, null=True,
        help_text=_('assigned mail domain for this domain')
    )

    objects = HostingDomainManager()

    class Meta:
        verbose_name = _('Hosting domain')
        verbose_name_plural = _('Hosting domains')

    def __str__(self):
        return self.domain


@python_2_unicode_compatible
class DNSDomain(DomainBase):
    """
    This model represents a DNS zone. The model is similar to the domain table
    in the PowerDNS schema specified in
    https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/.

    CREATE TABLE domains (
      id                    SERIAL PRIMARY KEY,
      name                  VARCHAR(255) NOT NULL,
      master                VARCHAR(128) DEFAULT NULL,
      last_check            INT DEFAULT NULL,
      type                  VARCHAR(6) NOT NULL,
      notified_serial       INT DEFAULT NULL,
      account               VARCHAR(40) DEFAULT NULL,
      CONSTRAINT c_lowercase_name CHECK (((name)::TEXT = LOWER((name)::TEXT)))
    );

    CREATE UNIQUE INDEX name_index ON domains(name);

    """
    # name is represented by domain
    master = models.CharField(max_length=128, blank=True, null=True)
    last_check = models.IntegerField(null=True)
    domaintype = models.CharField(max_length=6, choices=DNS_DOMAIN_TYPES,
            db_column='type')
    notified_serial = models.IntegerField(null=True)
    # account is represented by customer_id
    # check constraint is added via RunSQL in migration

    class Meta:
        verbose_name = _('DNS domain')
        verbose_name_plural = _('DNS domains')

    def __str__(self):
        return self.domain


@python_2_unicode_compatible
class DNSRecord(models.Model):
    """
    This model represents a DNS record. The model is similar to the record
    table in the PowerDNS schema specified in
    https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/.

    CREATE TABLE records (
      id                    SERIAL PRIMARY KEY,
      domain_id             INT DEFAULT NULL,
      name                  VARCHAR(255) DEFAULT NULL,
      type                  VARCHAR(10) DEFAULT NULL,
      content               VARCHAR(65535) DEFAULT NULL,
      ttl                   INT DEFAULT NULL,
      prio                  INT DEFAULT NULL,
      change_date           INT DEFAULT NULL,
      disabled              BOOL DEFAULT 'f',
      ordername             VARCHAR(255),
      auth                  BOOL DEFAULT 't',
      CONSTRAINT domain_exists
      FOREIGN KEY(domain_id) REFERENCES domains(id)
      ON DELETE CASCADE,
      CONSTRAINT c_lowercase_name CHECK (((name)::TEXT = LOWER((name)::TEXT)))
    );

    CREATE INDEX rec_name_index ON records(name);
    CREATE INDEX nametype_index ON records(name,type);
    CREATE INDEX domain_id ON records(domain_id);
    CREATE INDEX recordorder ON records (domain_id, ordername text_pattern_ops);

    """
    domain = models.ForeignKey('DNSDomain')
    name = models.CharField(max_length=255, blank=True, null=True,
            db_index=True)
    recordtype = models.CharField(max_length=10, blank=True, null=True,
            db_column='type')
    content = models.CharField(max_length=65535, blank=True, null=True)
    ttl = models.IntegerField(null=True)
    prio = models.IntegerField(null=True)
    change_date = models.IntegerField(null=True)
    disabled = models.BooleanField(default=False)
    ordername = models.CharField(max_length=255)
    auth = models.BooleanField(default=True)
    # check constraint and index recordorder are added via RunSQL in migration

    class Meta:
        verbose_name = _('DNS record')
        verbose_name_plural = _('DNS records')
        index_together = [
            ['name', 'recordtype']
        ]

    def __str__(self):
        return "{name} IN {type} {content}".format(
            name=self.name, type=self.recordtype, content=self.content)


@python_2_unicode_compatible
class DNSSupermaster(models.Model):
    """
    This model represents the supermasters table in the PowerDNS schema
    specified in
    https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/.

    CREATE TABLE supermasters (
      ip                    INET NOT NULL,
      nameserver            VARCHAR(255) NOT NULL,
      account               VARCHAR(40) NOT NULL,
      PRIMARY KEY(ip, nameserver)
    );

    """
    ip = models.GenericIPAddressField()
    nameserver = models.CharField(max_length=255)
    # account is replaced by customer
    customer = models.ForeignKey(
        settings.AUTH_USER_MODEL, verbose_name=_('customer'))

    class Meta:
        verbose_name = _('DNS supermaster')
        verbose_name_plural = _('DNS supermasters')
        unique_together = (
            ('ip', 'nameserver')
        )

    def __str__(self):
        return "{ip} {nameserver}".format(
            ip=self.ip, nameserver=self.nameserver)


@python_2_unicode_compatible
class DNSComment(models.Model):
    """
    This model represents the comments table in the PowerDNS schema specified
    in https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/. The
    comments table is used to store user comments related to individual DNS
    records.

    CREATE TABLE comments (
      id                    SERIAL PRIMARY KEY,
      domain_id             INT NOT NULL,
      name                  VARCHAR(255) NOT NULL,
      type                  VARCHAR(10) NOT NULL,
      modified_at           INT NOT NULL,
      account               VARCHAR(40) DEFAULT NULL,
      comment               VARCHAR(65535) NOT NULL,
      CONSTRAINT domain_exists
      FOREIGN KEY(domain_id) REFERENCES domains(id)
      ON DELETE CASCADE,
      CONSTRAINT c_lowercase_name CHECK (((name)::TEXT = LOWER((name)::TEXT)))
    );

    CREATE INDEX comments_domain_id_idx ON comments (domain_id);
    CREATE INDEX comments_name_type_idx ON comments (name, type);
    CREATE INDEX comments_order_idx ON comments (domain_id, modified_at);

    """
    domain = models.ForeignKey('DNSDomain')
    name = models.CharField(max_length=255)
    commenttype = models.CharField(max_length=10, db_column='type')
    modified_at = models.IntegerField()
    # account is replaced by customer
    customer = models.ForeignKey(
        settings.AUTH_USER_MODEL, verbose_name=_('customer'))
    comment = models.CharField(max_length=65535)
    # check constraint is added via RunSQL in migration

    class Meta:
        verbose_name = _('DNS comment')
        verbose_name_plural = _('DNS comments')
        index_together = [
            ['name', 'commenttype'],
            ['domain', 'modified_at']
        ]

    def __str__(self):
        return "{name} IN {type}: {comment}".format(
            name=self.name, type=self.commenttype, comment=self.comment)


@python_2_unicode_compatible
class DNSDomainMetadata(models.Model):
    """
    This model represents the domainmetadata table in the PowerDNS schema
    specified in
    https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/.
    The domainmetadata table is used to store domain meta data as described in
    https://doc.powerdns.com/md/authoritative/domainmetadata/.

    CREATE TABLE domainmetadata (
      id                    SERIAL PRIMARY KEY,
      domain_id             INT REFERENCES domains(id) ON DELETE CASCADE,
      kind                  VARCHAR(32),
      content               TEXT
    );

    CREATE INDEX domainidmetaindex ON domainmetadata(domain_id);
    """
    domain = models.ForeignKey('DNSDomain')
    kind = models.CharField(max_length=32, choices=DNS_DOMAIN_METADATA_KINDS)
    content = models.TextField()

    class Meta:
        verbose_name = _('DNS domain metadata item')
        verbose_name_plural = _('DNS domain metadata items')

    def __str__(self):
        return "{domain} {kind} {content}".format(
            domain=self.domain.domain, kind=self.kind, content=self.content)


@python_2_unicode_compatible
class DNSCryptoKey(models.Model):
    """
    This model represents the cryptokeys table in the PowerDNS schema
    specified in
    https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/.

    CREATE TABLE cryptokeys (
      id                    SERIAL PRIMARY KEY,
      domain_id             INT REFERENCES domains(id) ON DELETE CASCADE,
      flags                 INT NOT NULL,
      active                BOOL,
      content               TEXT
    );

    CREATE INDEX domainidindex ON cryptokeys(domain_id);
    """
    domain = models.ForeignKey('DNSDomain')
    flags = models.IntegerField()
    active = models.BooleanField(default=True)
    content = models.TextField()

    class Meta:
        verbose_name = _('DNS crypto key')
        verbose_name_plural = _('DNS crypto keys')

    def __str__(self):
        return "{domain} {content}".format(
            domain=self.domain.domain, content=self.content)


@python_2_unicode_compatible
class DNSTSIGKey(models.Model):
    """
    This model represents the tsigkeys table in the PowerDNS schema specified
    in https://doc.powerdns.com/md/authoritative/backend-generic-mypgsql/.

    CREATE TABLE tsigkeys (
      id                    SERIAL PRIMARY KEY,
      name                  VARCHAR(255),
      algorithm             VARCHAR(50),
      secret                VARCHAR(255),
      CONSTRAINT c_lowercase_name CHECK (((name)::TEXT = LOWER((name)::TEXT)))
    );

    CREATE UNIQUE INDEX namealgoindex ON tsigkeys(name, algorithm);
    """
    name = models.CharField(max_length=255)
    algorithm = models.CharField(max_length=50, choices=DNS_TSIG_KEY_ALGORITHMS)
    secret = models.CharField(max_length=255)
    # check constraint is added via RunSQL in migration

    class Meta:
        verbose_name = _('DNS TSIG key')
        verbose_name_plural = _('DNS TSIG keys')
        unique_together = [
            ['name', 'algorithm']
        ]

    def __str__(self):
        return "{name} {algorithm} XXXX".format(
            name=self.name, algorithm=self.algorithm)