terraform {
  required_version = "> 0.8.0"
  required_providers {
    docker = {
      source  = "kreuzwerker/docker"
      version = "4.6.0"
    }
  }
}

provider "kubernetes" {
  config_path = "~/.kube/config"
}

provider "docker" {
  host = "unix:///var/run/docker.sock"
}
provider "helm" {
  kubernetes = {
    config_path = "~/.kube/config"
  }
}

variable "kubernetes" {
  type = map(object({
    name   = optional(string)
    docker = optional(bool)
    image  = string
    pvc = optional(map(object({
      name                 = optional(string)
      config_map           = optional(bool, false)
      secret               = optional(bool, false)
      local_path           = optional(bool, false)
      host_path            = optional(string)
      storage_class_name   = optional(string, "nfs-storage-intelligent")
      annotations_fileType = optional(string)
      mount_path           = string
      sub_path             = optional(string)
    })))
    environment = optional(map(object({
      name  = optional(string)
      value = optional(string)
      value_from = optional(object({
        secret_key_ref = object({
          name = string
          key  = optional(string, null)
        })
      }))
    })))
    replicas               = optional(number, 1)
    namespace              = optional(string)
    connected_namespace    = optional(string, "")
    command                = optional(list(string))
    service_port           = optional(list(number))
    external_port          = optional(bool, false)
    service_type           = optional(string, "ClusterIP")
    service_name           = optional(string)
    domain_name            = optional(list(string))
    legacy_domain          = optional(bool, false)
    exposed                = optional(bool, true)
    liveness_tcp_socket    = optional(number)
    liveness_http_get      = optional(string)
    liveness_http_get_path = optional(string)
    database               = optional(map(string))
    database_command       = optional(list(string))
    database_args          = optional(list(string))
    redis                  = optional(map(string))
    enabled                = optional(bool, true)
    secret_ref             = optional(list(string))
    config_map_ref         = optional(list(string))
    config_map_import      = optional(list(string))
    secret_import          = optional(list(string))
    extra_manifest         = optional(list(string))
    requirements           = optional(map(string))
    dns_nameservers        = optional(string)
    service_account_name   = optional(string)
    environment_variables  = optional(map(string), { name = "value" })
    security_context       = optional(bool, false)
  }))

}

variable "shunt_docker" {
  type    = bool
  default = true
}

variable "storage_path" {
  type = map(string)
  default = {
    main_storage = "/data/kubernetes",
    fast_access  = "/ssd"
  }
}


locals {
  env_details = flatten([
    for key, value in var.kubernetes : [
      for index, env in value.environment_variables : {
        index = index
        name  = env
    }] if value.enabled == true && value.environment_variables != null && value.docker != true
  ])
}




locals {
  kubernetes_manifests = flatten([
    for k, obj in var.kubernetes : [
      for index, manifest in(obj.extra_manifest != null ? obj.extra_manifest : []) :
      {
        key      = "${k}_${index}"
        name     = obj.name
        manifest = manifest
        enabled  = obj.enabled
      }
      if obj.enabled == true
    ]
  ])
}

resource "kubernetes_manifest" "manifest" {
  for_each = { for item in local.kubernetes_manifests : item.key => item }

  manifest = yamldecode(file(each.value.manifest))
  provider = kubernetes
}

resource "kubernetes_namespace_v1" "automatic" {
  for_each = { for key, value in var.kubernetes : key => value if value.enabled == true && value.connected_namespace == "" }
  metadata {
    annotations = {
      name = coalesce(each.value.namespace, each.key)
    }
    labels = {
      deployment_method = "Terraform"
    }
    name = coalesce(each.value.namespace, each.key)
  }
}