# -*- coding: utf-8 -*- #
# Copyright 2016 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 compute routers commands."""

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

from googlecloudsdk.api_lib.compute import utils
from googlecloudsdk.calliope import arg_parsers
from googlecloudsdk.command_lib.compute import completers as compute_completers
from googlecloudsdk.command_lib.compute import flags as compute_flags
from googlecloudsdk.command_lib.util.apis import arg_utils

DEFAULT_CREATE_FORMAT = """\
    table(
      name,
      region.basename(),
      network.basename().if(network),
      ncc_gateway.basename().if(ncc_gateway)
    )"""

DEFAULT_LIST_FORMAT = """\
    table(
      name,
      region.basename(),
      network.basename().yesno(no="N/A")
    )"""

_MODE_CHOICES = {
    'DEFAULT': 'Default (Google-managed) BGP advertisements.',
    'CUSTOM': 'Custom (user-configured) BGP advertisements.',
}

_GROUP_CHOICES = {
    'ALL_SUBNETS': (
        'Automatically advertise all available subnets. This excludes '
        'any routes learned for subnets that use VPC Network Peering.'
    ),
}

_BFD_SESSION_INITIALIZATION_MODE_CHOICES = {
    'ACTIVE': (
        'The Cloud Router will initiate the BFD session for this BGP peer.'
    ),
    'PASSIVE': (
        'The Cloud Router will wait for the peer router to initiate the BFD '
        'session for this BGP peer.'
    ),
    'DISABLED': 'BFD is disabled for this BGP peer.',
}


class RoutersCompleter(compute_completers.ListCommandCompleter):

  def __init__(self, **kwargs):
    super(RoutersCompleter, self).__init__(
        collection='compute.routers',
        list_command='compute routers list --uri',
        **kwargs
    )


def RouterArgument(required=True, plural=False):
  return compute_flags.ResourceArgument(
      resource_name='router',
      completer=RoutersCompleter,
      plural=plural,
      required=required,
      regional_collection='compute.routers',
      region_explanation=compute_flags.REGION_PROPERTY_EXPLANATION,
  )


def RouterArgumentForVpnTunnel(required=True):
  return compute_flags.ResourceArgument(
      resource_name='router',
      name='--router',
      completer=RoutersCompleter,
      plural=False,
      required=required,
      regional_collection='compute.routers',
      short_help='Router to use for dynamic routing.',
      region_explanation=compute_flags.REGION_PROPERTY_EXPLANATION,
  )


def RouterArgumentForOtherResources(required=True, suppress_region=True):
  region_explanation = (
      'Should be the same as --region, if not specified, '
      'it will be inherited from --region.'
  )
  return compute_flags.ResourceArgument(
      resource_name='router',
      name='--router',
      completer=RoutersCompleter,
      plural=False,
      required=required,
      regional_collection='compute.routers',
      short_help='Google Cloud Router to use for dynamic routing.',
      region_explanation=region_explanation,
      region_hidden=suppress_region,
  )


def RouterArgumentForNat():
  return compute_flags.ResourceArgument(
      resource_name='router',
      name='--router',
      completer=RoutersCompleter,
      plural=False,
      required=True,
      regional_collection='compute.routers',
      short_help='Router to use for NAT.',
      region_hidden=True,
  )


def AddCreateRouterArgs(parser):
  """Adds common arguments for creating routers."""

  parser.add_argument(
      '--description', help='An optional description of this router.'
  )

  AddAsnArg(parser)


def AddKeepaliveIntervalArg(parser):
  """Adds keepalive interval argument for routers."""
  parser.add_argument(
      '--keepalive-interval',
      type=arg_parsers.Duration(
          default_unit='s', lower_bound='20s', upper_bound='60s'
      ),
      help=(
          'The interval between BGP keepalive messages that are sent to the'
          ' peer. If set, this value must be between 20 and 60 seconds. The'
          ' default is 20 seconds. See $ gcloud topic datetimes for information'
          ' on duration formats.\n\nBGP systems exchange keepalive messages to'
          ' determine whether a link or host has failed or is no longer'
          ' available. Hold time is the length of time in seconds that the BGP'
          ' session is considered operational without any activity. After the'
          ' hold time expires, the session is dropped.\n\nHold time is three'
          ' times the interval at which keepalive messages are sent, and the'
          ' hold time is the maximum number of seconds allowed to elapse'
          ' between successive keepalive messages that BGP receives from a'
          ' peer. BGP will use the smaller of either the local hold time value'
          " or the peer's  hold time value as the hold time for the BGP"
          ' connection between the two peers.'
      ),
  )


def AddBgpIdentifierRangeArg(parser):
  """Adds BGP identifier range argument for routers."""
  parser.add_argument(
      '--bgp-identifier-range',
      type=utils.IPV4RangeArgument,
      help=(
          'The range of valid BGP Identifiers for this Router. Must be a'
          ' link-local IPv4 range from 169.254.0.0/16, of size at least /30,'
          ' even if the BGP sessions are over IPv6. It must not overlap with'
          ' any IPv4 BGP session ranges. This is commonly called "router ID" by'
          ' other vendors.'
      ),
  )


def AddNccGatewayArg(parser):
  """NccGateway for router."""
  parser.add_argument(
      '--ncc-gateway',
      type=str,
      help='The NCC gateway for this router.',
  )


def AddAsnArg(parser):
  """Adds Asn argument for routers."""
  parser.add_argument(
      '--asn',
      required=False,
      type=int,
      help=(
          'The optional BGP autonomous system number (ASN) for this router. '
          'Must be a 16-bit or 32-bit private ASN as defined in '
          'https://tools.ietf.org/html/rfc6996, for example `--asn=64512`.'
      ),
  )


def AddInterfaceArgs(parser, for_update=False):
  """Adds common arguments for routers add-interface or update-interface."""

  operation = 'added'
  if for_update:
    operation = 'updated'

  parser.add_argument(
      '--interface-name',
      required=True,
      help='The name of the interface being {0}.'.format(operation),
  )

  parser.add_argument(
      '--ip-address',
      type=utils.IPArgument,
      help=(
          'The link local (IPv4) or ULA (IPv6) address of the router for this'
          ' interface.'
      ),
  )
  parser.add_argument(
      '--mask-length',
      type=arg_parsers.BoundedInt(lower_bound=0, upper_bound=126),
      help=(
          'The subnet mask for the IP range of the interface. The interface'
          ' IP address and BGP peer IP address must be selected from the'
          ' subnet defined by this range.'
      ),
  )
  parser.add_argument(
      '--ip-version',
      type=arg_utils.ChoiceToEnumName,
      choices={
          'IPV4': 'Interface with IPv4-based BGP.',
          'IPV6': 'Interface with IPv6-based BGP.',
      },
      help=(
          'IP version of the interface. Possible values are IPV4 and IPV6.'
          ' Defaults to IPV4.'
      ),
  )

  if not for_update:
    parser.add_argument(
        '--redundant-interface',
        help='The interface that is redundant to the current interface.',
    )


def AddBgpPeerArgs(parser, for_add_bgp_peer=False, is_update=False):
  """Adds common arguments for managing BGP peers."""

  operation = 'updated'
  if for_add_bgp_peer:
    operation = 'added'

  parser.add_argument(
      '--peer-name',
      required=True,
      help='The name of the new BGP peer being {0}.'.format(operation),
  )

  parser.add_argument(
      '--interface',
      required=for_add_bgp_peer,
      help='The name of the interface for this BGP peer.',
  )

  parser.add_argument(
      '--peer-asn',
      required=for_add_bgp_peer,
      type=int,
      help=(
          'The BGP autonomous system number (ASN) for this BGP peer. '
          'Must be a 16-bit or 32-bit private ASN as defined in '
          'https://tools.ietf.org/html/rfc6996, for example `--asn=64512`.'
      ),
  )

  # For add_bgp_peer, we only require the interface and infer the IP instead.
  if not for_add_bgp_peer:
    parser.add_argument(
        '--ip-address',
        type=utils.IPArgument,
        help=(
            'The address of the Cloud Router interface for this BGP peer.'
            ' Must be a link-local IPv4 address in  the range 169.254.0.0/16'
            ' or an ULA IPv6 address in the range fdff:1::/64. It must also'
            ' be in the same subnet as the interface address of the peer'
            ' router.'
        ),
    )

  parser.add_argument(
      '--peer-ip-address',
      type=utils.IPArgument,
      help=(
          'The address of the peer router. Must be a link-local IPv4 address'
          ' in the range 169.254.0.0/16 or an ULA IPv6 address in the'
          ' range fdff:1::/64.'
      ),
  )

  parser.add_argument(
      '--advertised-route-priority',
      type=arg_parsers.BoundedInt(lower_bound=0, upper_bound=65535),
      help=(
          'The priority of routes advertised to this BGP peer. In the case '
          'where there is more than one matching route of maximum length, '
          'the routes with lowest priority value win. 0 <= priority <= '
          '65535. If not specified, will use Google-managed priorities.'
      ),
  )

  bfd_group_help = (
      'Arguments to {0} BFD (Bidirectional Forwarding Detection) '
      'settings:'.format('update' if is_update else 'configure')
  )
  bfd_group = parser.add_group(help=bfd_group_help)
  bfd_group.add_argument(
      '--bfd-session-initialization-mode',
      choices=_BFD_SESSION_INITIALIZATION_MODE_CHOICES,
      type=lambda mode: mode.upper(),
      metavar='BFD_SESSION_INITIALIZATION_MODE',
      help=(
          'The BFD session initialization mode for this BGP peer. Must be one'
          ' of:\n\nACTIVE - The Cloud Router will initiate the BFD session for'
          ' this BGP peer.\n\nPASSIVE - The Cloud Router will wait for the peer'
          ' router to initiate the BFD session for this BGP peer.\n\nDISABLED -'
          ' BFD is disabled for this BGP peer.'
      ),
  )

  bfd_group.add_argument(
      '--bfd-min-transmit-interval',
      type=arg_parsers.Duration(
          default_unit='ms',
          lower_bound='1000ms',
          upper_bound='30000ms',
          parsed_unit='ms',
      ),
      help=(
          'The minimum transmit interval between BFD control packets. The '
          'default is 1000 milliseconds. See $ gcloud topic datetimes for '
          'information on duration formats.'
      ),
  )
  bfd_group.add_argument(
      '--bfd-min-receive-interval',
      type=arg_parsers.Duration(
          default_unit='ms',
          lower_bound='1000ms',
          upper_bound='30000ms',
          parsed_unit='ms',
      ),
      help=(
          'The minimum receive interval between BFD control packets. The '
          'default is 1000 milliseconds. See $ gcloud topic datetimes for '
          'information on duration formats.'
      ),
  )
  bfd_group.add_argument(
      '--bfd-multiplier',
      type=int,
      help=(
          'The number of consecutive BFD control packets that must be '
          'missed before BFD declares that a peer is unavailable.'
      ),
  )

  enabled_display_help = (
      'If enabled, the peer connection can be established with routing '
      'information. If disabled, any active session with the peer is '
      'terminated and all associated routing information is removed.'
  )

  if not is_update:
    enabled_display_help += ' Enabled by default.'
  parser.add_argument(
      '--enabled',
      action=arg_parsers.StoreTrueFalseAction,
      help=enabled_display_help,
  )

  enable_ipv6_display_help = (
      'If IPv6 is enabled, the peer connection can be established with '
      'IPv6 route exchange. If disabled, no IPv6 route exchange is allowed '
      'on any active session.'
  )
  if not is_update:
    enable_ipv6_display_help += ' Disabled by default.'
  parser.add_argument(
      '--enable-ipv6',
      action=arg_parsers.StoreTrueFalseAction,
      help=enable_ipv6_display_help,
  )

  parser.add_argument(
      '--ipv6-nexthop-address',
      type=utils.IPV6Argument,
      help=(
          'If IPv6 route exchange is enabled for IPv4-based BGP, the IPv6 next'
          ' hop address of the Cloud Router interface for this BGP peer.'
          ' Ignored otherwise. Must be a Google owned global unicast IPv6'
          ' address belonging to the range 2600:2d00:0:2:0:0:0:0/64 or'
          ' 2600:2d00:0:3:0:0:0:0/64 and must belong to same subnet as the'
          ' interface address of the peer router.'
      ),
  )

  parser.add_argument(
      '--peer-ipv6-nexthop-address',
      type=utils.IPV6Argument,
      help=(
          'If IPv6 route exchange is enabled for IPv4-based BGP, the IPv6 next'
          ' hop address of the peer router. Ignored otherwise. Must be a Google'
          ' owned global unicast IPv6 address belonging to the range'
          ' 2600:2d00:0:2:0:0:0:0/64 or 2600:2d00:0:3:0:0:0:0/64.'
      ),
  )

  enable_ipv4_display_help = (
      'If IPv4 is enabled, the peer connection can be established with '
      'IPv4 route exchange. If disabled, no IPv4 route exchange is allowed '
      'on any active session.'
  )
  if not is_update:
    enable_ipv4_display_help += (
        ' By default enabled for IPv4-based BGP sessions.'
    )
  parser.add_argument(
      '--enable-ipv4',
      action=arg_parsers.StoreTrueFalseAction,
      help=enable_ipv4_display_help,
  )

  parser.add_argument(
      '--ipv4-nexthop-address',
      type=utils.IPV4Argument,
      help=(
          'If IPv4 route exchange is enabled for IPv6-based BGP, the IPv4'
          ' next hop address of the Cloud Router interface for this BGP peer.'
          ' Ignored otherwise. Must be a Google owned link-local IPv4 address'
          ' in the range 169.254.0.0/16 and must belong to the same subnet as'
          ' the interface address of the peer router.'
      ),
  )

  parser.add_argument(
      '--peer-ipv4-nexthop-address',
      type=utils.IPV4Argument,
      help=(
          'If IPv4 route exchange is enabled for IPv6-based BGP, the IPv4'
          ' next hop address of the peer router. Ignored otherwise. Must be a'
          ' Google owned link-local IPv4 address in the range 169.254.0.0/16.'
      ),
  )

  parser.add_argument(
      '--md5-authentication-key',
      type=str,
      help=(
          'The MD5 authentication key for this BGP peer. Maximum length is '
          '80 characters. Can contain only printable ASCII characters.'
      ),
  )

  if is_update:
    parser.add_argument(
        '--clear-md5-authentication-key',
        action='store_true',
        default=None,
        help='If specified, remove MD5 authentication from the BGP peer.',
    )
  parser.add_argument(
      '--export-policies',
      metavar='EXPORT_POLICY',
      type=arg_parsers.ArgList(),
      help=(
          'Comma-separated list of export policies. Passing an empty string'
          ' removes all export policies.'
      ),
  )
  parser.add_argument(
      '--import-policies',
      type=arg_parsers.ArgList(),
      metavar='IMPORT_POLICY',
      help=(
          'Comma-separated list of import policies. Passing an empty string'
          ' removes all import policies.'
      ),
  )


def AddUpdateCustomAdvertisementArgs(parser, resource_str):
  """Adds common arguments for setting/updating custom advertisements."""

  AddReplaceCustomAdvertisementArgs(parser, resource_str)
  AddIncrementalCustomAdvertisementArgs(parser, resource_str)


def AddReplaceCustomAdvertisementArgs(parser, resource_str):
  """Adds common arguments for replacing custom advertisements."""

  parser.add_argument(
      '--advertisement-mode',
      choices=_MODE_CHOICES,
      type=lambda mode: mode.upper(),
      metavar='MODE',
      help="""The new advertisement mode for this {0}.""".format(resource_str),
  )

  parser.add_argument(
      '--set-advertisement-groups',
      type=arg_parsers.ArgList(
          choices=_GROUP_CHOICES, element_type=lambda group: group.upper()
      ),
      metavar='GROUP',
      help="""The list of pre-defined groups of IP ranges to dynamically
              advertise on this {0}. This list can only be specified in
              custom advertisement mode.""".format(resource_str),
  )

  parser.add_argument(
      '--set-advertisement-ranges',
      type=arg_parsers.ArgDict(allow_key_only=True),
      metavar='CIDR_RANGE=DESC',
      help="""The list of individual IP ranges, in CIDR format, to dynamically
              advertise on this {0}. Each IP range can (optionally) be given a
              text description DESC. For example, to advertise a specific range,
              use `--set-advertisement-ranges=192.168.10.0/24`.  To store a
              description with the range, use
              `--set-advertisement-ranges=192.168.10.0/24=my-networks`. This
              list can only be specified in custom advertisement mode.""".format(
          resource_str
      ),
  )


def AddIncrementalCustomAdvertisementArgs(parser, resource_str):
  """Adds common arguments for incrementally updating custom advertisements."""

  incremental_args = parser.add_mutually_exclusive_group(required=False)

  incremental_args.add_argument(
      '--add-advertisement-groups',
      type=arg_parsers.ArgList(
          choices=_GROUP_CHOICES, element_type=lambda group: group.upper()
      ),
      metavar='GROUP',
      help="""A list of pre-defined groups of IP ranges to dynamically advertise
              on this {0}. This list is appended to any existing advertisements.
              This field can only be specified in custom advertisement mode.""".format(
          resource_str
      ),
  )

  incremental_args.add_argument(
      '--remove-advertisement-groups',
      type=arg_parsers.ArgList(
          choices=_GROUP_CHOICES, element_type=lambda group: group.upper()
      ),
      metavar='GROUP',
      help="""A list of pre-defined groups of IP ranges to remove from dynamic
              advertisement on this {0}. Each group in the list must exist in
              the current set of custom advertisements. This field can only be
              specified in custom advertisement mode.""".format(resource_str),
  )

  incremental_args.add_argument(
      '--add-advertisement-ranges',
      type=arg_parsers.ArgDict(allow_key_only=True),
      metavar='CIDR_RANGE=DESC',
      help="""A list of individual IP ranges, in CIDR format, to dynamically
              advertise on this {0}. This list is appended to any existing
              advertisements. Each IP range can (optionally) be given a text
              description DESC. For example, to advertise a specific range, use
              `--advertisement-ranges=192.168.10.0/24`.  To store a description
              with the range, use
              `--advertisement-ranges=192.168.10.0/24=my-networks`. This list
              can only be specified in custom advertisement mode.""".format(
          resource_str
      ),
  )

  incremental_args.add_argument(
      '--remove-advertisement-ranges',
      type=arg_parsers.ArgList(),
      metavar='CIDR_RANGE',
      help="""A list of individual IP ranges, in CIDR format, to remove from
              dynamic advertisement on this {0}. Each IP range in the list must
              exist in the current set of custom advertisements. This field can
              only be specified in custom advertisement mode.""".format(
          resource_str
      ),
  )


def AddUpdateCustomLearnedRoutesArgs(parser):
  """Adds common arguments for setting/updating custom learned routes.

  Args:
    parser: The parser to parse arguments.
  """

  AddReplaceCustomLearnedRoutesArgs(parser)
  AddIncrementalCustomLearnedRoutesArgs(parser)


def AddReplaceCustomLearnedRoutesArgs(parser):
  """Adds common arguments for replacing custom learned routes.

  Args:
    parser: The parser to parse arguments.
  """

  parser.add_argument(
      '--custom-learned-route-priority',
      type=arg_parsers.BoundedInt(lower_bound=0, upper_bound=65535),
      metavar='PRIORITY',
      help="""An integral value `0` <= priority <= `65535`, to be applied to all
              custom learned route IP address ranges for this peer. If not
              specified, a Google-managed priority value of 100 is used. The
              routes with the lowest priority value win.""",
  )

  parser.add_argument(
      '--set-custom-learned-route-ranges',
      type=arg_parsers.ArgList(),
      metavar='CIDR_RANGE',
      help="""The list of user-defined custom learned route IP address ranges
              for this peer. This list is a comma separated IP address ranges
              such as `1.2.3.4`,`6.7.0.0/16`,`2001:db8:abcd:12::/64` where each
              IP address range must be a valid CIDR-formatted prefix. If an IP
              address is provided without a subnet mask, it is interpreted as a
              /32 singular IP address range for IPv4, and /128 for IPv6.""",
  )


def AddIncrementalCustomLearnedRoutesArgs(parser):
  """Adds common arguments for incrementally updating custom learned routes.

  Args:
    parser: The parser to parse arguments.
  """

  incremental_args = parser.add_mutually_exclusive_group(required=False)

  incremental_args.add_argument(
      '--add-custom-learned-route-ranges',
      type=arg_parsers.ArgList(),
      metavar='CIDR_RANGE',
      help="""A list of user-defined custom learned route IP address ranges to
              be added to this peer. This list is a comma separated IP address
              ranges such as `1.2.3.4`,`6.7.0.0/16`,`2001:db8:abcd:12::/64`
              where each IP address range must be a valid CIDR-formatted prefix.
              If an IP address is provided without a subnet mask, it is
              interpreted as a /32 singular IP address range for IPv4, and /128
              for IPv6.""",
  )

  incremental_args.add_argument(
      '--remove-custom-learned-route-ranges',
      type=arg_parsers.ArgList(),
      metavar='CIDR_RANGE',
      help="""A list of user-defined custom learned route IP address ranges to
              be removed from this peer. This list is a comma separated IP
              address ranges such as `1.2.3.4`,`6.7.0.0/16`,`2001:db8:abcd:12::/64`
              where each IP address range must be a valid CIDR-formatted prefix.
              If an IP address is provided without a subnet mask, it is
              interpreted as a /32 singular IP address range for IPv4, and /128
              for IPv6.""",
  )


def AddGetNatMappingInfoArgs(parser):
  """Adds common arguments for get-nat-mapping-info."""

  parser.add_argument(
      '--nat-name',
      required=False,
      help='The NAT name to filter out NAT mapping information',
  )


def AddGetNatIpInfoArgs(parser):
  """Adds common arguments for get-ip-mapping-info."""

  parser.add_argument(
      '--nat-name',
      required=False,
      help='The NAT name to filter out NAT IP information',
  )


def AddEncryptedInterconnectRouter(parser):
  """Adds encrypted interconnect router flag."""
  parser.add_argument(
      '--encrypted-interconnect-router',
      required=False,
      action='store_true',
      default=None,
      help=(
          'Indicates if a router is dedicated for use with encrypted '
          'interconnect attachments (VLAN attachments).'
      ),
  )