# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from __future__ import with_statement

import copy

from libcloud.dns.types import Provider, RecordType
from libcloud.dns.types import RecordError
from libcloud.dns.types import ZoneDoesNotExistError, \
    RecordDoesNotExistError, ZoneAlreadyExistsError, RecordAlreadyExistsError
from libcloud.dns.base import DNSDriver, Zone, Record
from libcloud.common.gandi_live import ResourceNotFoundError, \
    ResourceConflictError, GandiLiveResponse, GandiLiveConnection, \
    BaseGandiLiveDriver


__all__ = [
    'GandiLiveDNSDriver',
]


TTL_MIN = 300
TTL_MAX = 2592000  # 30 days
API_BASE = '/api/v5'


class GandiLiveDNSResponse(GandiLiveResponse):
    pass


class GandiLiveDNSConnection(GandiLiveConnection):
    responseCls = GandiLiveDNSResponse


class GandiLiveDNSDriver(BaseGandiLiveDriver, DNSDriver):
    """
    API reference can be found at:

    https://doc.livedns.gandi.net/

    Please note that the Libcloud paradigm of one zone per domain does not
    match exactly with Gandi LiveDNS.  For Gandi, a "zone" can apply to
    multiple domains.  This driver behaves as if the domain is a zone, but be
    warned that modifying a domain means modifying the zone.  Iif you have a
    zone associated with mutiple domains, all of those domains will be
    modified as well.
    """

    type = Provider.GANDI
    name = 'Gandi LiveDNS'
    website = 'http://www.gandi.net/domain'

    connectionCls = GandiLiveDNSConnection

    # also supports CAA, CDS
    RECORD_TYPE_MAP = {
        RecordType.A: 'A',
        RecordType.AAAA: 'AAAA',
        RecordType.ALIAS: 'ALIAS',
        RecordType.CNAME: 'CNAME',
        RecordType.DNAME: 'DNAME',
        RecordType.DS: 'DS',
        RecordType.KEY: 'KEY',
        RecordType.LOC: 'LOC',
        RecordType.MX: 'MX',
        RecordType.NS: 'NS',
        RecordType.PTR: 'PTR',
        RecordType.SPF: 'SPF',
        RecordType.SRV: 'SRV',
        RecordType.SSHFP: 'SSHFP',
        RecordType.TLSA: 'TLSA',
        RecordType.TXT: 'TXT',
        RecordType.WKS: 'WKS',
        RecordType.CAA: 'CAA',
    }

    def list_zones(self):
        zones = self.connection.request(action='%s/domains' % API_BASE,
                                        method='GET')
        return self._to_zones(zones.object)

    def get_zone(self, zone_id):
        action = '%s/domains/%s' % (API_BASE, zone_id)
        try:
            zone = self.connection.request(action=action, method='GET')
        except ResourceNotFoundError:
            raise ZoneDoesNotExistError(value='',
                                        driver=self.connection.driver,
                                        zone_id=zone_id)
        return self._to_zone(zone.object)

    """
    :param extra: (optional) Extra attribute ('name'); if not provided, name
                             is based on domain.

    :return: :class:`Zone` with attribute zone_uuid set in extra ``dict``
    """
    def create_zone(self, domain, type='master', ttl=None, extra=None):
        if extra and 'name' in extra:
            zone_name = extra['name']
        else:
            zone_name = '%s zone' % domain
        zone_data = {
            'name': zone_name,
        }

        try:
            new_zone = self.connection.request(action='%s/zones' % API_BASE,
                                               method='POST',
                                               data=zone_data)
        except ResourceConflictError:
            raise ZoneAlreadyExistsError(value='',
                                         driver=self.connection.driver,
                                         zone_id=zone_name)
        new_zone_uuid = new_zone.headers['location'].split('/')[-1]

        self.ex_switch_domain_gandi_zone(domain, new_zone_uuid)

        return self._to_zone({'fqdn': domain, 'zone_uuid': new_zone_uuid})

    def list_records(self, zone):
        action = '%s/domains/%s/records' % (API_BASE, zone.id)
        records = self.connection.request(action=action, method='GET')
        return self._to_records(records.object, zone)

    """
    :return: :class:`Record` with the extra ``dict`` containing attribute
             other_values ``list`` of ``str`` for other values; the first
             value is returned through Record.data.
    """
    def get_record(self, zone_id, record_id):
        record_type, name = record_id.split(':', 1)
        action = '%s/domains/%s/records/%s/%s' % (API_BASE,
                                                  zone_id,
                                                  name,
                                                  record_type)
        try:
            record = self.connection.request(action=action, method='GET')
        except ResourceNotFoundError:
            raise RecordDoesNotExistError(value='',
                                          driver=self.connection.driver,
                                          record_id=record_id)
        return self._to_record(record.object, self.get_zone(zone_id))[0]

    def create_record(self, name, zone, type, data, extra=None):
        self._validate_record(None, name, type, data, extra)

        action = '%s/domains/%s/records' % (API_BASE, zone.id)

        if type == 'MX':
            data = '%s %s' % (extra['priority'], data)

        record_data = {
            'rrset_name': name,
            'rrset_type': self.RECORD_TYPE_MAP[type],
            'rrset_values': [data],
        }

        if extra is not None and 'ttl' in extra:
            record_data['rrset_ttl'] = extra['ttl']

        try:
            self.connection.request(action=action, method='POST',
                                    data=record_data)
        except ResourceConflictError:
            raise RecordAlreadyExistsError(value='',
                                           driver=self.connection.driver,
                                           record_id='%s:%s' % (
                                               self.RECORD_TYPE_MAP[type],
                                               name))

        return self._to_record_sub(record_data, zone, data)

    """
    Ignores name and type, not allowed in an update call to the service.

    The Gandi service requires all values for a record when doing an update.
    Not providing all values during an update means the service will interpret
    it as replacing all values with the one data value.  The easiest way to
    accomplish this is to make sure the value of a get_record is used as the
    value of the record parameter.

    This method will change the value when only one exists.  When more than
    one exists, it will combine the data parameter value with the extra dict
    values contained in the list extra['_other_records'].  This method should
    only be used to make single value updates.

    To change the number of values in the value set or to change several at
    once, delete and recreate, potentially using ex_create_multi_value_record.
    """
    def update_record(self, record, name, type, data, extra):
        self._validate_record(record.id, record.name, record.type, data, extra)

        action = '%s/domains/%s/records/%s/%s' % (
            API_BASE,
            record.zone.id,
            record.name,
            self.RECORD_TYPE_MAP[record.type]
        )

        multiple_value_record = record.extra.get('_multi_value', False)
        other_records = record.extra.get('_other_records', [])

        if record.type == RecordType.MX:
            data = '%s %s' % (extra['priority'], data)

        if multiple_value_record and len(other_records) > 0:
            rvalue = [data]
            for other_record in other_records:
                if record.type == RecordType.MX:
                    rvalue.append('%s %s' %
                                  (other_record['extra']['priority'],
                                   other_record['data']))
                else:
                    rvalue.append(other_record['data'])
        else:
            rvalue = [data]

        record_data = {
            'rrset_values': rvalue
        }

        if extra is not None and 'ttl' in extra:
            record_data['rrset_ttl'] = extra['ttl']

        try:
            self.connection.request(action=action, method='PUT',
                                    data=record_data)
        except ResourceNotFoundError:
            raise RecordDoesNotExistError(value='',
                                          driver=self.connection.driver,
                                          record_id=record.id)

        record_data['rrset_name'] = record.name
        record_data['rrset_type'] = self.RECORD_TYPE_MAP[record.type]
        return self._to_record(record_data, record.zone)[0]

    """
    The Gandi service considers all values for a name-type combination to be
    one record.  Deleting that name-type record means deleting all values for
    it.
    """
    def delete_record(self, record):
        action = '%s/domains/%s/records/%s/%s' % (
            API_BASE,
            record.zone.id,
            record.name,
            self.RECORD_TYPE_MAP[record.type]
        )
        try:
            self.connection.request(action=action, method='DELETE')
        except ResourceNotFoundError:
            raise RecordDoesNotExistError(value='',
                                          driver=self.connection.driver,
                                          record_id=record.id)
        # Originally checked for success here, but it should never reach
        # this point with anything other than HTTP 200
        return True

    def export_zone_to_bind_format(self, zone):
        action = '%s/domains/%s/records' % (API_BASE, zone.id)
        headers = {
            'Accept': 'text/plain'
        }
        resp = self.connection.request(action=action, method='GET',
                                       headers=headers, raw=True)
        return resp.body

    # There is nothing you can update about a domain; you can update zones'
    # names and which zone a domain is associated with, but the domain itself
    # is basically immutable.  Instead, some ex_ methods for dealing with
    # Gandi zones.

    """
    Update the name of a Gandi zone.

    Note that a Gandi zone is not the same as a Libcloud zone.  A Gandi zone
    is a separate object type from a Gandi domain; a Gandi zone can be reused
    by multiple Gandi domains, and the actual records are associated with the
    zone directly.  This is mostly masked in this driver to make it look like
    records are associated with domains.  If you need to step out of that
    masking, use these extension methods.

    :param zone_uuid: Identifier for the Gandi zone.
    :type  zone_uuid: ``str``

    :param name: New name for the Gandi zone.
    :type  name: ``str``

    :return: ``bool``
    """
    def ex_update_gandi_zone_name(self, zone_uuid, name):
        action = '%s/zones/%s' % (API_BASE, zone_uuid)
        data = {
            'name': name,
        }
        self.connection.request(action=action, method='PATCH',
                                data=data)
        return True

    # There is no concept of deleting domains in this API, not even to
    # disassociate a domain from a zone.  You can delete a zone, though.
    """
    Delete a Gandi zone.  This may raise a ResourceConflictError if you
    try to delete a zone that has domains still using it.

    :param zone_uuid: Identifier for the Gandi zone
    :type  zone_uuid: ``str``

    :return: ``bool``
    """
    def ex_delete_gandi_zone(self, zone_uuid):
        self.connection.request(action='%s/zones/%s' % (API_BASE, zone_uuid),
                                method='DELETE')
        return True

    """
    Change the Gandi zone a domain is asociated with.

    :param domain: Domain name to switch zones.
    :type  domain: ``str``

    :param zone_uuid: Identifier for the new Gandi zone to switch to.
    :type  zone_uuid: ``str``

    :return: ``bool``
    """
    def ex_switch_domain_gandi_zone(self, domain, zone_uuid):
        domain_data = {
            'zone_uuid': zone_uuid,
        }
        self.connection.request(action='%s/domains/%s' % (API_BASE, domain),
                                method='PATCH',
                                data=domain_data)
        return True

    """
    Create a new record with multiple values.

    :param data: Record values (depends on the record type)
    :type  data: ``list`` (of ``str``)

    :return: ``list`` of :class:`Record`s
    """
    def ex_create_multi_value_record(self, name, zone, type, data, extra=None):
        self._validate_record(None, name, type, data, extra)

        action = '%s/domains/%s/records' % (API_BASE, zone.id)

        record_data = {
            'rrset_name': name,
            'rrset_type': self.RECORD_TYPE_MAP[type],
            'rrset_values': data,
        }

        if extra is not None and 'ttl' in extra:
            record_data['rrset_ttl'] = extra['ttl']

        try:
            self.connection.request(action=action, method='POST',
                                    data=record_data)
        except ResourceConflictError:
            raise RecordAlreadyExistsError(value='',
                                           driver=self.connection.driver,
                                           record_id='%s:%s' % (
                                               self.RECORD_TYPE_MAP[type],
                                               name))
        return self._to_record(record_data, zone)

    def _to_record(self, data, zone):
        records = []
        rrset_values = data['rrset_values']
        multiple_value_record = len(rrset_values) > 1

        for index, rrset_value in enumerate(rrset_values):
            record = self._to_record_sub(data, zone, rrset_value)
            record.extra['_multi_value'] = multiple_value_record
            if multiple_value_record:
                record.extra['_other_records'] = []
            records.append(record)

        if multiple_value_record:
            for index in range(0, len(records)):
                record = records[index]
                for other_index, other_record in enumerate(records):
                    if index == other_index:
                        continue

                    extra = copy.deepcopy(other_record.extra)
                    extra.pop('_multi_value')
                    extra.pop('_other_records')

                    item = {
                        'name': other_record.name,
                        'data': other_record.data,
                        'type': other_record.type,
                        'extra': extra
                    }
                    record.extra['_other_records'].append(item)
        return records

    def _to_record_sub(self, data, zone, value):
        extra = {}
        ttl = data.get('rrset_ttl', None)
        if ttl is not None:
            extra['ttl'] = int(ttl)
        if data['rrset_type'] == 'MX':
            priority, value = value.split()
            extra['priority'] = priority
        return Record(
            id='%s:%s' % (data['rrset_type'], data['rrset_name']),
            name=data['rrset_name'],
            type=self._string_to_record_type(data['rrset_type']),
            data=value,
            zone=zone,
            driver=self,
            ttl=ttl,
            extra=extra)

    def _to_records(self, data, zone):
        records = []
        for r in data:
            records += self._to_record(r, zone)
        return records

    def _to_zone(self, zone):
        extra = {}
        if 'zone_uuid' in zone:
            extra = {
                'zone_uuid': zone['zone_uuid']
            }
        return Zone(
            id=str(zone['fqdn']),
            domain=zone['fqdn'],
            type='master',
            ttl=0,
            driver=self,
            extra=extra,
        )

    def _to_zones(self, zones):
        ret = []
        for z in zones:
            ret.append(self._to_zone(z))
        return ret

    def _validate_record(self, record_id, name, record_type, data, extra):
        if len(data) > 1024:
            raise RecordError('Record data must be <= 1024 characters',
                              driver=self, record_id=record_id)
        if type == 'MX' or type == RecordType.MX:
            if extra is None or 'priority' not in extra:
                raise RecordError('MX record must have a priority',
                                  driver=self, record_id=record_id)
        if extra is not None and '_other_records' in extra:
            for other_value in extra.get('_other_records', []):
                if len(other_value['data']) > 1024:
                    raise RecordError('Record data must be <= 1024 characters',
                                      driver=self, record_id=record_id)
                if type == 'MX' or type == RecordType.MX:
                    if (other_value['extra'] is None
                            or 'priority' not in other_value['extra']):
                        raise RecordError('MX record must have a priority',
                                          driver=self, record_id=record_id)
        if extra is not None and 'ttl' in extra:
            if extra['ttl'] < TTL_MIN:
                raise RecordError('TTL must be at least 300 seconds',
                                  driver=self, record_id=record_id)
            if extra['ttl'] > TTL_MAX:
                raise RecordError('TTL must not exceed 30 days',
                                  driver=self, record_id=record_id)