# -*- coding: utf-8 -*- #
# Copyright 2025 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.
"""Helpers for flags in commands working with Anthos Multi-Cloud on Attached."""

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

from googlecloudsdk.calliope import arg_parsers


def AddPlatformVersion(parser, required=True):
  """Adds platform version flag.

  Args:
    parser: The argparse.parser to add the arguments to.
    required: Indicates if the flag is required.
  """

  help_text = """
Platform version to use for the cluster.

To retrieve a list of valid versions, run:

  $ gcloud alpha container attached get-server-config --location=LOCATION

Replace ``LOCATION'' with the target Google Cloud location for the cluster.
"""

  parser.add_argument('--platform-version', required=required, help=help_text)


def GetPlatformVersion(args):
  return getattr(args, 'platform_version', None)


def AddIssuerUrl(parser, required=False):
  parser.add_argument(
      '--issuer-url',
      required=required,
      help='Issuer url of the cluster to attach.',
  )


def GetIssuerUrl(args):
  return getattr(args, 'issuer_url', None)


def AddOidcJwks(parser):
  parser.add_argument('--oidc-jwks', help='OIDC JWKS of the cluster to attach.')


def GetOidcJwks(args):
  return getattr(args, 'oidc_jwks', None)


def AddHasPrivateIssuer(parser):
  help_text = """Indicates no publicly routable OIDC discovery endpoint exists
for the Kubernetes service account token issuer.

If this flag is set, gcloud will read the issuer URL and JWKs from the cluster's
api server.
"""
  parser.add_argument(
      '--has-private-issuer', help=help_text, action='store_true'
  )


def GetHasPrivateIssuer(args):
  return getattr(args, 'has_private_issuer', None)


def AddOidcConfig(parser):
  """Adds Oidc Config flags.

  Args:
    parser: The argparse.parser to add the arguments to.
  """

  group = parser.add_group('OIDC config', required=True)
  AddIssuerUrl(group, required=True)
  AddOidcJwks(group)


def AddRegisterOidcConfig(parser):
  group = parser.add_mutually_exclusive_group('OIDC config', required=True)
  AddIssuerUrl(group)
  AddHasPrivateIssuer(group)


def AddDistribution(parser, required=False):
  help_text = """
Set the base platform type of the cluster to attach.

Examples:

  $ {command} --distribution=aks
  $ {command} --distribution=eks
  $ {command} --distribution=generic
"""
  parser.add_argument('--distribution', required=required, help=help_text)


def GetDistribution(args):
  return getattr(args, 'distribution', None)


def AddAdminUsersForUpdate(parser):
  """Adds admin user configuration flags for update.

  Args:
    parser: The argparse.parser to add the arguments to.
  """

  group = parser.add_group('Admin users', mutex=True)
  AddAdminUsers(group)
  AddClearAdminUsers(group)


def AddAdminUsers(parser):
  help_txt = """
Users that can perform operations as a cluster administrator.
"""

  parser.add_argument(
      '--admin-users',
      type=arg_parsers.ArgList(),
      metavar='USER',
      required=False,
      help=help_txt,
  )


def AddClearAdminUsers(parser):
  """Adds flag for clearing admin users.

  Args:
    parser: The argparse.parser to add the arguments to.
  """

  parser.add_argument(
      '--clear-admin-users',
      action='store_true',
      default=None,
      help='Clear the admin users associated with the cluster',
  )


def GetAdminUsers(args):
  if not hasattr(args, 'admin_users'):
    return None
  if args.admin_users:
    return args.admin_users
  return None


def AddKubectl(parser):
  group = parser.add_group('kubectl config', required=True)
  AddKubeconfig(group)
  AddContext(group)


def AddKubeconfig(parser):
  help_txt = """Path to the kubeconfig file.

If not provided, the default at ~/.kube/config will be used.
"""
  parser.add_argument('--kubeconfig', help=help_txt)


def GetKubeconfig(args):
  return getattr(args, 'kubeconfig', None)


def AddContext(parser):
  help_txt = """Context to use in the kubeconfig."""
  parser.add_argument('--context', required=True, help=help_txt)


def GetContext(args):
  return getattr(args, 'context', None)


def AddProxySecretName(parser, required=False):
  help_txt = """
Name of the Kubernetes secret that contains the HTTP/HTTPS
proxy configuration.
"""
  parser.add_argument(
      '--proxy-secret-name',
      required=required,
      help=help_txt,
  )


def GetProxySecretName(args):
  return getattr(args, 'proxy_secret_name', None)


def AddProxySecretNamespace(parser, required=False):
  help_txt = """
Namespace of the Kubernetes secret that contains the HTTP/HTTPS
proxy configuration.
"""
  parser.add_argument(
      '--proxy-secret-namespace',
      required=required,
      help=help_txt,
  )


def GetProxySecretNamespace(args):
  return getattr(args, 'proxy_secret_namespace', None)


def AddProxyConfig(parser):
  """Adds Proxy Config flags.

  Args:
    parser: The argparse.parser to add the arguments to.
  """

  group = parser.add_group('Proxy config', required=False)
  AddProxySecretName(group, required=True)
  AddProxySecretNamespace(group, required=True)


def AddSkipClusterAdminCheck(parser):
  """Adds --skip-cluster-admin-check flag to parser.

  Args:
    parser: The argparse.parser to add the arguments to.
  """
  help_text = """\
When this hidden flag is set, the cluster admin check will be skipped.
"""
  parser.add_argument(
      '--skip-cluster-admin-check',
      hidden=True,
      help=help_text,
      action='store_true',
  )


def GetSkipClusterAdminCheck(args):
  return getattr(args, 'skip_cluster_admin_check', None)


def AddSystemComponentLabels(parser):
  """Adds --system-component-labels flag to parser.

  Args:
    parser: The argparse.parser to add the arguments to.
  """
  help_text = """\
Kubernetes labels to be applied to system component pods.
"""
  parser.add_argument(
      '--system-component-labels',
      help=help_text,
      type=arg_parsers.ArgDict(),
      metavar='LABEL',
  )


def GetSystemComponentLabels(args):
  return getattr(args, 'system_component_labels', None)


def AddSystemComponentTolerations(parser):
  """Adds --system-component-tolerations flag to parser.

  Args:
    parser: The argparse.parser to add the arguments to.
  """
  help_text = """\
Kubernetes tolerations to be applied to system component pods.
"""
  parser.add_argument(
      '--system-component-tolerations',
      type=arg_parsers.ArgList(),
      help=help_text,
      metavar='TOLERATION',
  )


def GetSystemComponentTolerations(args):
  tolerations = getattr(args, 'system_component_tolerations', None)
  if tolerations:
    tol = [ParseSystemComponentToleration(t) for t in tolerations]
    return tol
  return None


def ParseSystemComponentToleration(toleration):
  """Parses a system component toleration string.

  Args:
    toleration: The toleration string to parse.

  Returns:
    A list of (key, value, operator, effect).
  """
  parts = toleration.split(':')
  if len(parts) != 3:
    raise ValueError(
        'System component toleration must be in the format of'
        ' key=value:operator:effect, key:operator:effect, or :operator:effect,'
        ' got %s' % toleration
    )
  if not parts[0]:
    return ['', '', parts[1], parts[2]]
  key_value = parts[0].split('=')
  if not key_value:
    return ['', '', parts[1], parts[2]]
  elif len(key_value) == 1:
    return [key_value[0], '', parts[1], parts[2]]
  elif len(key_value) == 2:
    return [key_value[0], key_value[1], parts[1], parts[2]]
  else:
    raise ValueError(
        'System component toleration must be in the format of'
        ' key=value:operator:effect, key:operator:effect, or :operator:effect,'
        ' got %s' % toleration
    )