# -*- coding: utf-8 -*- #
# Copyright 2020 Google LLC. All Rights Reserved.
#
# Licensed 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.
"""API client library for Cloud Domains Registrations."""

from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals

from apitools.base.py import list_pager
from googlecloudsdk.api_lib.util import apis
from googlecloudsdk.calliope import base
from googlecloudsdk.core import exceptions
from googlecloudsdk.core import log

ALPHA_API_VERSION = 'v1alpha2'
BETA_API_VERSION = 'v1beta1'
GA_API_VERSION = 'v1'


def GetApiVersionFromArgs(args):
  """Return API version based on args."""
  release_track = args.calliope_command.ReleaseTrack()
  if release_track == base.ReleaseTrack.ALPHA:
    return ALPHA_API_VERSION
  if release_track == base.ReleaseTrack.BETA:
    return BETA_API_VERSION
  if release_track == base.ReleaseTrack.GA:
    return GA_API_VERSION
  raise exceptions.UnsupportedReleaseTrackError(release_track)


def GetClientInstance(api_version):
  return apis.GetClientInstance('domains', api_version)


def GetMessagesModule(api_version, client=None):
  client = client or GetClientInstance(api_version)
  return client.MESSAGES_MODULE


class RegistrationsClient(object):
  """Client for registrations service in the Cloud Domains API."""

  def __init__(self, api_version, client=None, messages=None):
    self.client = client or GetClientInstance(api_version)
    self.messages = messages or GetMessagesModule(api_version, client)
    self._service = self.client.projects_locations_registrations

  def PrintSQSPAck(self):
    """Prints FYI acknowledgement about the Google Domains - Squarespace deal."""
    ack_message = (
        'Domain name registration services are provided by Squarespace '
        '(https://domains.squarespace.com),\n'
        'pursuant to the Squarespace Terms of Service '
        '(https://www.squarespace.com/terms-of-service)\n'
        'and Squarespace Domain Registration Agreement '
        '(https://www.squarespace.com/domain-registration-agreement),\n'
        'which Google resells pursuant to an agreement with Squarespace.\n'
        'Google shares your name, contact information, and other '
        'domain-related information with Squarespace.\n'
        "You can review Squarespace's Privacy Policy "
        '(https://www.squarespace.com/privacy) for details on how they '
        'process your information.\n'
        "Google's Privacy Policy (https://policies.google.com/privacy) "
        'describes how Google handles this information as a reseller.\n'
        "By choosing to continue, you (1) acknowledge receipt of Google's "
        'Privacy Policy and direct us to share this information\n'
        'with Squarespace; and (2) agree to the Squarespace Terms of Service '
        '(https://www.squarespace.com/terms-of-service) and\n'
        'Squarespace Domain Registration Agreement '
        '(https://www.squarespace.com/domain-registration-agreement), and\n'
        "acknowledge receipt of Squarespace's Privacy Policy "
        '(https://www.squarespace.com/privacy).\n'
    )

    log.status.Print(ack_message)

  def Register(
      self,
      parent_ref,
      domain,
      dns_settings,
      contact_settings,
      yearly_price,
      labels=None,
      hsts_notice_accepted=False,
      public_privacy_accepted=False,
      validate_only=False,
  ):
    """Creates a Registration.

    Args:
      parent_ref: a Resource reference to a domains.projects.locations resource
        for the parent of this registration.
      domain: str, the name of the domain to register. Used as resource name.
      dns_settings: DnsSettings to be used.
      contact_settings: ContactSettings to be used.
      yearly_price: price for the domain registration and its cost for the
        following years.
      labels: Unified GCP Labels for the resource.
      hsts_notice_accepted: bool, Whether HSTS notice was presented & accepted.
      public_privacy_accepted: bool, Whether public privacy notice was presented
        & accepted.
      validate_only: If set to true, performs only validation, without creating.

    Returns:
      Operation: the long running operation to register a domain.
    """
    domain_notices = []
    if hsts_notice_accepted:
      domain_notices = [
          self.messages.RegisterDomainRequest.DomainNoticesValueListEntryValuesEnum.HSTS_PRELOADED
      ]
    contact_notices = []
    if public_privacy_accepted:
      contact_notices = [
          self.messages.RegisterDomainRequest.ContactNoticesValueListEntryValuesEnum.PUBLIC_CONTACT_DATA_ACKNOWLEDGEMENT
      ]
    req = self.messages.DomainsProjectsLocationsRegistrationsRegisterRequest(
        parent=parent_ref.RelativeName(),
        registerDomainRequest=self.messages.RegisterDomainRequest(
            registration=self.messages.Registration(
                domainName=domain,
                dnsSettings=dns_settings,
                contactSettings=contact_settings,
                labels=labels,
            ),
            domainNotices=domain_notices,
            contactNotices=contact_notices,
            yearlyPrice=yearly_price,
            validateOnly=validate_only,
        ),
    )

    return self._service.Register(req)

  def Transfer(
      self,
      parent_ref,
      domain,
      dns_settings,
      contact_settings,
      authorization_code,
      yearly_price,
      labels=None,
      public_privacy_accepted=False,
      validate_only=False,
  ):
    """Transfers a domain and creates a new Registration.

    Args:
      parent_ref: a Resource reference to a domains.projects.locations resource
        for the parent of this registration.
      domain: str, the name of the domain to transfer. Used as resource name.
      dns_settings: DnsSettings to be used.
      contact_settings: ContactSettings to be used.
      authorization_code: The authorization code needed to transfer the domain.
      yearly_price: price for the domain transfer and its cost for the following
        years.
      labels: Unified GCP Labels for the resource.
      public_privacy_accepted: bool, Whether public privacy notice was presented
        & accepted.
      validate_only: If set to true, performs only validation, without
        transferring.

    Returns:
      Operation: the long running operation to transfer a domain.
    """
    contact_notices = []
    if public_privacy_accepted:
      contact_notices = [
          self.messages.TransferDomainRequest.ContactNoticesValueListEntryValuesEnum.PUBLIC_CONTACT_DATA_ACKNOWLEDGEMENT
      ]

    registration = self.messages.Registration(
        domainName=domain,
        dnsSettings=dns_settings,
        contactSettings=contact_settings,
        labels=labels,
    )

    req = self.messages.DomainsProjectsLocationsRegistrationsTransferRequest(
        parent=parent_ref.RelativeName(),
        transferDomainRequest=self.messages.TransferDomainRequest(
            registration=registration,
            contactNotices=contact_notices,
            authorizationCode=self.messages.AuthorizationCode(
                code=authorization_code
            ),
            yearlyPrice=yearly_price,
            validateOnly=validate_only,
        ),
    )

    return self._service.Transfer(req)

  def Import(self, parent_ref, domain, labels):
    """Imports a domain and creates a new Registration.

    Args:
      parent_ref: a Resource reference to a domains.projects.locations resource
        for the parent of this registration.
      domain: str, the name of the domain to import. Used as resource name.
      labels: Unified GCP Labels for the resource.

    Returns:
      Operation: the long running operation to import a domain.
    """
    req = self.messages.DomainsProjectsLocationsRegistrationsImportRequest(
        parent=parent_ref.RelativeName(),
        importDomainRequest=self.messages.ImportDomainRequest(
            domainName=domain, labels=labels
        ),
    )
    return self._service.Import(req)

  def Export(self, registration_ref):
    req = self.messages.DomainsProjectsLocationsRegistrationsExportRequest(
        name=registration_ref.RelativeName()
    )
    return self._service.Export(req)

  def Renew(self, registration_ref, yearly_price, validate_only=False):
    req = self.messages.DomainsProjectsLocationsRegistrationsRenewDomainRequest(
        registration=registration_ref.RelativeName(),
        renewDomainRequest=self.messages.RenewDomainRequest(
            yearlyPrice=yearly_price, validateOnly=validate_only
        ),
    )
    return self._service.RenewDomain(req)

  def Delete(self, registration_ref):
    req = self.messages.DomainsProjectsLocationsRegistrationsDeleteRequest(
        name=registration_ref.RelativeName()
    )
    return self._service.Delete(req)

  def Get(self, registration_ref):
    get_req = self.messages.DomainsProjectsLocationsRegistrationsGetRequest(
        name=registration_ref.RelativeName()
    )
    return self._service.Get(get_req)

  def RetrieveAuthorizationCode(self, registration_ref):
    # pylint: disable=line-too-long
    req = self.messages.DomainsProjectsLocationsRegistrationsRetrieveAuthorizationCodeRequest(
        registration=registration_ref.RelativeName()
    )
    return self._service.RetrieveAuthorizationCode(req)

  def ResetAuthorizationCode(self, registration_ref):
    # pylint: disable=line-too-long
    req = self.messages.DomainsProjectsLocationsRegistrationsResetAuthorizationCodeRequest(
        registration=registration_ref.RelativeName()
    )
    return self._service.ResetAuthorizationCode(req)

  def InitiatePushTransfer(self, registration_ref, tag):
    req = self.messages.DomainsProjectsLocationsRegistrationsInitiatePushTransferRequest(
        registration=registration_ref.RelativeName(),
        initiatePushTransferRequest=self.messages.InitiatePushTransferRequest(
            tag=tag
        ),
    )
    return self._service.InitiatePushTransfer(req)

  def RetrieveImportableDomains(
      self, parent_ref, limit=None, page_size=None, batch_size=None
  ):
    request = self.messages.DomainsProjectsLocationsRegistrationsRetrieveImportableDomainsRequest(
        location=parent_ref.RelativeName(), pageSize=page_size
    )

    return list_pager.YieldFromList(
        self._service,
        request,
        method='RetrieveImportableDomains',
        field='domains',
        limit=limit,
        batch_size=batch_size,
        batch_size_attribute='pageSize',
    )

  def List(self, parent_ref, limit=None, page_size=None, list_filter=None):
    """List the domain registrations in a given project.

    Args:
      parent_ref: a Resource reference to a domains.projects.locations resource
        to list registrations for.
      limit: int, the total number of results to return from the API.
      page_size: int, the number of results in each batch from the API.
      list_filter: str, filter to apply in the list request.

    Returns:
      A generator of the domain registrations in the project.
    """
    list_req = self.messages.DomainsProjectsLocationsRegistrationsListRequest(
        parent=parent_ref.RelativeName(), filter=list_filter
    )
    return list_pager.YieldFromList(
        self._service,
        list_req,
        batch_size=page_size,
        limit=limit,
        field='registrations',
        batch_size_attribute='pageSize',
    )

  def Patch(self, registration_ref, labels=None):
    """Updates a Registration.

    Used for updating labels.

    Args:
      registration_ref: a Resource reference to a
        domains.projects.locations.registrations resource.
      labels: Unified GCP Labels for the resource.

    Returns:
      Operation: the long running operation to patch registration.
    """
    registration = self.messages.Registration()
    registration.labels = labels
    update_mask = 'labels'

    patch_req = self.messages.DomainsProjectsLocationsRegistrationsPatchRequest(
        registration=registration,
        name=registration_ref.RelativeName(),
        updateMask=update_mask,
    )

    return self._service.Patch(patch_req)

  def ConfigureManagement(
      self, registration_ref, transfer_lock, preferred_renewal_method
  ):
    """Updates management settings.

    Args:
      registration_ref: a Resource reference to a
        domains.projects.locations.registrations resource.
      transfer_lock: The transfer lock state.
      preferred_renewal_method: The preferred Renewal Method.

    Returns:
      Operation: the long running operation to configure management
        registration.
    """
    management_settings = self.messages.ManagementSettings(
        transferLockState=transfer_lock,
        preferredRenewalMethod=preferred_renewal_method,
    )

    updated_list = []
    if transfer_lock:
      updated_list += ['transfer_lock_state']
    if preferred_renewal_method:
      updated_list += ['preferred_renewal_method']
    update_mask = ','.join(updated_list)
    # pylint: disable=line-too-long
    req = self.messages.DomainsProjectsLocationsRegistrationsConfigureManagementSettingsRequest(
        registration=registration_ref.RelativeName(),
        configureManagementSettingsRequest=self.messages.ConfigureManagementSettingsRequest(
            managementSettings=management_settings, updateMask=update_mask
        ),
    )

    return self._service.ConfigureManagementSettings(req)

  def ConfigureDNS(
      self, registration_ref, dns_settings, updated, validate_only
  ):
    """Calls ConfigureDNSSettings method.

    Args:
      registration_ref: Registration resource reference.
      dns_settings: New DNS Settings.
      updated: dns_util.DnsUpdateMask object representing an update mask.
      validate_only: validate_only flag.

    Returns:
      Long Running Operation reference.
    """

    updated_list = []
    if updated.glue_records:
      updated_list += ['glue_records']
    if updated.google_domains_dnssec:
      if updated.name_servers:
        updated_list += ['google_domains_dns']
      else:
        updated_list += ['google_domains_dns.ds_state']
    if updated.custom_dnssec:
      if updated.name_servers:
        updated_list += ['custom_dns']
      else:
        updated_list += ['custom_dns.ds_records']
    update_mask = ','.join(updated_list)

    # pylint: disable=line-too-long
    req = self.messages.DomainsProjectsLocationsRegistrationsConfigureDnsSettingsRequest(
        registration=registration_ref.RelativeName(),
        configureDnsSettingsRequest=self.messages.ConfigureDnsSettingsRequest(
            dnsSettings=dns_settings,
            updateMask=update_mask,
            validateOnly=validate_only,
        ),
    )

    return self._service.ConfigureDnsSettings(req)

  def ConfigureContacts(
      self,
      registration_ref,
      contacts,
      contact_privacy,
      public_contacts_ack,
      validate_only,
  ):
    """Calls ConfigureContactSettings method.

    Args:
      registration_ref: Registration resource reference.
      contacts: New Contacts.
      contact_privacy: New Contact privacy.
      public_contacts_ack: Whether the user accepted public privacy.
      validate_only: validate_only flag.

    Returns:
      Long Running Operation reference.
    """
    updated_list = []
    if contact_privacy:
      updated_list += ['privacy']

    if contacts is None:
      contact_settings = self.messages.ContactSettings(privacy=contact_privacy)
    else:
      contact_settings = self.messages.ContactSettings(
          privacy=contact_privacy,
          registrantContact=contacts.registrantContact,
          adminContact=contacts.adminContact,
          technicalContact=contacts.technicalContact,
      )

      if contacts.registrantContact:
        updated_list += ['registrant_contact']
      if contacts.adminContact:
        updated_list += ['admin_contact']
      if contacts.technicalContact:
        updated_list += ['technical_contact']

    update_mask = ','.join(updated_list)

    notices = []
    if public_contacts_ack:
      notices = [
          self.messages.ConfigureContactSettingsRequest.ContactNoticesValueListEntryValuesEnum.PUBLIC_CONTACT_DATA_ACKNOWLEDGEMENT
      ]

    # pylint: disable=line-too-long
    req = self.messages.DomainsProjectsLocationsRegistrationsConfigureContactSettingsRequest(
        registration=registration_ref.RelativeName(),
        configureContactSettingsRequest=self.messages.ConfigureContactSettingsRequest(
            contactSettings=contact_settings,
            updateMask=update_mask,
            contactNotices=notices,
            validateOnly=validate_only,
        ),
    )

    return self._service.ConfigureContactSettings(req)

  def ConfigureRegistrantEmail(self, registration_ref, registrant_email):
    """Sets a registrant contact.

    This resends registrant email confirmation.
    It's done by updating registrant email to the current value.

    Args:
      registration_ref: a Resource reference to a
        domains.projects.locations.registrations resource.
      registrant_email: The registrant email.

    Returns:
      Operation: the long running operation to configure contacts registration.
    """
    contact_settings = self.messages.ContactSettings(
        registrantContact=self.messages.Contact(email=registrant_email)
    )

    # pylint: disable=line-too-long
    req = self.messages.DomainsProjectsLocationsRegistrationsConfigureContactSettingsRequest(
        registration=registration_ref.RelativeName(),
        configureContactSettingsRequest=self.messages.ConfigureContactSettingsRequest(
            contactSettings=contact_settings,
            updateMask='registrant_contact.email',
        ),
    )

    return self._service.ConfigureContactSettings(req)

  def RetrieveRegisterParameters(self, parent_ref, domain):
    # pylint: disable=line-too-long
    request = self.messages.DomainsProjectsLocationsRegistrationsRetrieveRegisterParametersRequest(
        location=parent_ref.RelativeName(), domainName=domain
    )
    return self._service.RetrieveRegisterParameters(request).registerParameters

  def RetrieveTransferParameters(self, parent_ref, domain):
    # pylint: disable=line-too-long
    request = self.messages.DomainsProjectsLocationsRegistrationsRetrieveTransferParametersRequest(
        location=parent_ref.RelativeName(), domainName=domain
    )
    return self._service.RetrieveTransferParameters(request).transferParameters

  def SearchDomains(self, parent_ref, query):
    # pylint: disable=line-too-long
    request = (
        self.messages.DomainsProjectsLocationsRegistrationsSearchDomainsRequest(
            location=parent_ref.RelativeName(), query=query
        )
    )
    return self._service.SearchDomains(request).registerParameters

  def RetrieveGoogleDomainsDnsRecords(
      self, registration_ref, page_size, page_token
  ):
    # pylint: disable=line-too-long
    request = self.messages.DomainsProjectsLocationsRegistrationsRetrieveGoogleDomainsDnsRecordsRequest(
        registration=registration_ref.RelativeName(),
        pageToken=page_token,
        pageSize=page_size,
    )
    return self._service.RetrieveGoogleDomainsDnsRecords(request)

  def RetrieveGoogleDomainsForwardingConfig(self, registration_ref):
    # pylint: disable=line-too-long
    request = self.messages.DomainsProjectsLocationsRegistrationsRetrieveGoogleDomainsForwardingConfigRequest(
        registration=registration_ref.RelativeName(),
    )
    return self._service.RetrieveGoogleDomainsForwardingConfig(request)