# -*- 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.
"""Flags and helpers for the connection profiles cloudsql related commands."""


from googlecloudsdk.calliope import arg_parsers
from googlecloudsdk.calliope import base


_IP_ADDRESS_PART = r'(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})'  # Match decimal 0-255
_CIDR_PREFIX_PART = r'([0-9]|[1-2][0-9]|3[0-2])'  # Match decimal 0-32
# Matches either IPv4 range in CIDR notation or a naked IPv4 address.
_CIDR_REGEX = r'{addr_part}(\.{addr_part}){{3}}(\/{prefix_part})?$'.format(
    addr_part=_IP_ADDRESS_PART, prefix_part=_CIDR_PREFIX_PART)


def AddDatabaseVersionGroup(parser, support_new_versions, support_version_name):
  """Adds the database version flags to the given parser."""

  database_version_group = parser.add_group(required=True, mutex=True)
  AddDatabaseVersionFlag(database_version_group, support_new_versions)
  if support_version_name:
    AddDatabaseVersionNameFlag(database_version_group)


def AddDatabaseVersionFlag(parser, support_new_versions):
  """Adds a --database-version flag to the given parser."""
  help_text = """\
    Database engine type and version.
    """
  choices = [
      'MYSQL_5_7',
      'MYSQL_5_6',
      'MYSQL_8_0',
      'MYSQL_8_0_18',
      'MYSQL_8_0_26',
      'MYSQL_8_0_27',
      'MYSQL_8_0_28',
      'MYSQL_8_0_30',
      'MYSQL_8_0_31',
      'MYSQL_8_0_32',
      'MYSQL_8_0_33',
      'MYSQL_8_0_34',
      'MYSQL_8_0_35',
      'MYSQL_8_0_36',
      'MYSQL_8_0_37',
      'MYSQL_8_4',
      'POSTGRES_9_6',
      'POSTGRES_10',
      'POSTGRES_11',
      'POSTGRES_12',
      'POSTGRES_13',
      'POSTGRES_14',
      'POSTGRES_15',
      'POSTGRES_16',
  ]
  if not support_new_versions:
    choices = [
        'MYSQL_5_7',
        'MYSQL_5_6',
        'MYSQL_8_0',
        'POSTGRES_9_6',
        'POSTGRES_10',
        'POSTGRES_11',
        'POSTGRES_12',
        'POSTGRES_13',
        'POSTGRES_14',
        'POSTGRES_15',
    ]

  parser.add_argument(
      '--database-version', help=help_text, choices=choices, required=False
  )


def AddDatabaseVersionNameFlag(parser):
  """Adds a --database-version-name flag to the given parser."""
  help_text = 'Database version name (e.g. POSTGRES_15)'
  parser.add_argument('--database-version-name', help=help_text, required=False)


def AddUserLabelsFlag(parser):
  """Adds a --user-labels flag to the given parser."""
  help_text = """\
    The resource labels for a Cloud SQL instance to use to annotate any related
    underlying resources such as Compute Engine VMs. An object containing a list
    of "key": "value" pairs.
    """
  parser.add_argument(
      '--user-labels',
      metavar='KEY=VALUE',
      type=arg_parsers.ArgDict(),
      help=help_text)


def AddTierFlag(parser):
  """Adds a --tier flag to the given parser."""
  help_text = """\
    Tier (or machine type) for this instance, for example: ``db-n1-standard-1''
    (MySQL instances) or ``db-custom-1-3840'' (PostgreSQL instances). For more
    information, see
    [Cloud SQL Instance Settings](https://cloud.google.com/sql/docs/mysql/instance-settings).
    """
  parser.add_argument('--tier', help=help_text, required=True)


def AddEditionFlag(parser):
  """Adds a --edition flag to the given parser."""
  edition_flag = base.ChoiceArgument(
      '--edition',
      required=False,
      choices={
          'enterprise': (
              'Enterprise is the standard option for smaller instances.'
          ),
          'enterprise-plus': (
              'Enterprise plus option recommended for cpu-intensive workloads. '
              'Offers access to premium features and capabilities.'
          ),
      },
      default=None,
      help_str='Specifies edition.',
  )
  edition_flag.AddToParser(parser)


def AddStorageAutoResizeLimitFlag(parser):
  """Adds a --storage-auto-resize-limit flag to the given parser."""
  help_text = """\
    Maximum size to which storage capacity can be automatically increased. The
    default value is 0, which specifies that there is no limit.
    """
  parser.add_argument('--storage-auto-resize-limit', type=int, help=help_text)


def AddActivationPolicylag(parser):
  """Adds a --activation-policy flag to the given parser."""
  help_text = """\
    Activation policy specifies when the instance is activated; it is
    applicable only when the instance state is 'RUNNABLE'. Valid values:

    ALWAYS: The instance is on, and remains so even in the absence of
    connection requests.

    NEVER: The instance is off; it is not activated, even if a connection
    request arrives.
    """
  choices = ['ALWAYS', 'NEVER']
  parser.add_argument('--activation-policy', help=help_text, choices=choices)


def AddEnableIpv4Flag(parser):
  """Adds a --enable-ip-v4 flag to the given parser."""
  help_text = 'Whether the instance should be assigned an IPv4 address or not.'
  parser.add_argument(
      '--enable-ip-v4',
      help=help_text,
      action='store_true',
      dest='enable_ip_v4',
      default=True)


def AddPrivateNetworkFlag(parser):
  """Adds a --private-network flag to the given parser."""
  help_text = """\
    Resource link for the VPC network from which the Cloud SQL instance is
    accessible for private IP. For example,
    /projects/myProject/global/networks/default. This setting can be updated,
    but it cannot be removed after it is set.
    """
  parser.add_argument('--private-network', help=help_text)


def AddRequireSslFlag(parser):
  """Adds a --require-ssl flag to the given parser."""
  help_text = 'Whether SSL connections over IP should be enforced or not.'
  parser.add_argument(
      '--require-ssl',
      help=help_text,
      action='store_true',
      dest='require_ssl',
      default=False)


def AddAuthorizedNetworksFlag(parser):
  """Adds a `--authorized-networks` flag."""
  cidr_validator = arg_parsers.RegexpValidator(
      _CIDR_REGEX, ('Must be specified in CIDR notation, also known as '
                    '\'slash\' notation (e.g. 192.168.100.0/24).'))
  help_text = """\
    List of external networks that are allowed to connect to the instance.
    Specify values in CIDR notation, also known as 'slash' notation
    (e.g.192.168.100.0/24).
    """
  parser.add_argument(
      '--authorized-networks',
      type=arg_parsers.ArgList(min_length=1, element_type=cidr_validator),
      metavar='NETWORK',
      default=[],
      help=help_text)


def AddAutoStorageIncreaseFlag(parser):
  """Adds a --auto-storage-increase flag to the given parser."""
  help_text = """\
    If you enable this setting, Cloud SQL checks your available storage every
    30 seconds. If the available storage falls below a threshold size, Cloud
    SQL automatically adds additional storage capacity. If the available
    storage repeatedly falls below the threshold size, Cloud SQL continues to
    add storage until it reaches the maximum of 64 TB. Default: ON.
    """
  parser.add_argument(
      '--auto-storage-increase',
      help=help_text,
      action='store_true',
      dest='auto_storage_increase',
      default=True)


def AddDatabaseFlagsFlag(parser):
  """Adds a --database-flags flag to the given parser."""
  help_text = """\
    Comma-separated list of database flags to set on the instance. Use an equals
    sign to separate the flag name and value. Flags without values, like
    skip_grant_tables, can be written out without a value, e.g.,
    `skip_grant_tables=`. Use on/off values for booleans. View the Instance
    Resource API for allowed flags. (e.g., `--database-flags max_allowed_packet=55555
    skip_grant_tables=,log_output=1`).
  """
  parser.add_argument(
      '--database-flags',
      type=arg_parsers.ArgDict(),
      metavar='FLAG=VALUE',
      help=help_text)


def AddDataDiskTypeFlag(parser):
  """Adds a --data-disk-type flag to the given parser."""
  help_text = 'Type of storage.'
  choices = ['PD_SSD', 'PD_HDD']
  parser.add_argument('--data-disk-type', help=help_text, choices=choices)


def AddDataDiskSizeFlag(parser):
  """Adds a --data-disk-size flag to the given parser."""
  help_text = """\
    Storage capacity available to the database, in GB. The minimum (and
    default) size is 10GB.
  """
  parser.add_argument('--data-disk-size', type=int, help=help_text)


def AddAvailabilityTypeFlag(parser):
  """Adds a --availability-type flag to the given parser."""
  help_text = 'Cloud SQL availability type.'
  choices = ['REGIONAL', 'ZONAL']
  parser.add_argument('--availability-type', help=help_text, choices=choices)


def AddZoneFlag(parser):
  """Adds a --zone flag to the given parser."""
  help_text = """\
    Google Cloud Platform zone where your Cloud SQL database instance is
    located.
  """
  parser.add_argument('--zone', help=help_text)


def AddSecondaryZoneFlag(parser):
  """Adds a --secondary-zone flag to the given parser."""
  help_text = """\
    Google Cloud Platform zone where the failover Cloud SQL database
    instance is located. Used when the Cloud SQL database availability type
    is REGIONAL (i.e. multiple zones / highly available).
  """
  parser.add_argument('--secondary-zone', help=help_text)


def AddAllocatedIpRangeFlag(parser):
  """Adds a --allocated-ip-range flag to the given parser."""
  help_text = """\
    The name of the allocated IP range for the private IP Cloud SQL instance.
    This name refers to an already allocated IP range.
    If set, the instance IP will be created in the allocated range.
  """
  parser.add_argument('--allocated-ip-range', help=help_text)


def AddRootPassword(parser):
  """Add the root password field to the parser."""
  parser.add_argument(
      '--root-password',
      required=False,
      help="Root Cloud SQL user's password.")


def AddEnableDataCacheFlag(parser):
  """Adds a --enable-data-cache flag to the given parser."""
  parser.add_argument(
      '--enable-data-cache',
      hidden=True,
      required=False,
      action='store_true',
      dest='enable_data_cache',
      help=(
          'Enable use of data cache for accelerated read performance. This flag'
          ' is only available for Enterprise Plus edition instances.'
      )
  )
