terraform {
  required_version = "~> 0.12.21"
  required_providers {
    azurerm = "~> 1.44"
  }
}

resource "azurerm_lb" "azlb" {
  for_each = var.lbs

  name                = each.key
  resource_group_name = each.value.resource_group_name
  location            = each.value.location
  tags                = each.value.tags
  sku                 = try(each.value.sku, "Basic") #Basic or Standard

  dynamic "frontend_ip_configuration" {
    for_each = try(each.value.frontend_ip_configurations, {})
    content {
      name                          = try(frontend_ip_configuration.value.name, join("-ipc", [each.key, index(each.value.frontend_ip_configurations, frontend_ip_configuration)]))
      subnet_id                     = data.azurerm_subnet.sub[frontend_ip_configuration.value.name].id
      private_ip_address_allocation = try(frontend_ip_configuration.value.private_ip_address_allocation, "Static") #Static or Dynamic
      private_ip_address            = try(frontend_ip_configuration.value.private_ip_address_allocation, "Static") == "Static" ? frontend_ip_configuration.value.private_ip_address : null
      public_ip_address_id          = try(frontend_ip_configuration.value.public_ip_address_id, null)
      public_ip_prefix_id           = try(frontend_ip_configuration.value.public_ip_prefix_id, null)
      zones                         = try(frontend_ip_configuration.value.zones, null)
    }
  }
  depends_on = [var.azlb_depends_on]
}

locals {
  fipcs = flatten([
    for lbkey, lb in var.lbs : [
      for fipc in try(lb.frontend_ip_configurations, []) : {
        name                 = fipc.name
        rules                = try(fipc.rules, [])
        lb_name              = lbkey
        resource_group_name  = lb.resource_group_name
        subnet               = {
          name                 = fipc.subnet.name
          virtual_network_name = fipc.subnet.virtual_network_name
          resource_group_name  = try(fipc.subnet.resource_group_name, lb.resource_group_name)
        }
      }
    ]
  ])
}

data "azurerm_subnet" "sub" {
  for_each = {for fipc in local.fipcs: fipc.name => fipc}

  name                 = each.value.subnet.name
  virtual_network_name = each.value.subnet.virtual_network_name
  resource_group_name  = each.value.subnet.resource_group_name
  depends_on = [var.azlb_depends_on]
}

locals {
  bps = flatten([
    for lbkey, lb in var.lbs : [
      for bp in try(lb.backend_pools, []) : {
        name                = bp.name
        resource_group_name = lb.resource_group_name
        lb_name             = lbkey
        nics                = bp.nics
      }
    ]
  ])
}

resource "azurerm_lb_backend_address_pool" "azlbbpool" {
  for_each = {for bp in local.bps: bp.name => bp}

  name                = each.key
  resource_group_name = each.value.resource_group_name
  loadbalancer_id     = azurerm_lb.azlb[each.value.lb_name].id
}

locals {
  rules = flatten([
    for fipc in local.fipcs : [
      for rule in fipc.rules : {
        name                = rule.name
        resource_group_name = fipc.resource_group_name
        lb_name             = fipc.lb_name
        fipc_name           = fipc.name
        protocol            = rule.protocol # Tcp, Udp or All
        frontend_port       = rule.frontend_port
        backend_port        = rule.backend_port
        backend_pool_name   = rule.backend_pool_name
        load_distribution   = rule.load_distribution # 'Default', SourceIP, SourceIPProtocol
        probe               = rule.probe
      }
    ]
  ])
}

locals {
  probes = flatten([
    for rule in local.rules : {
      name                = rule.probe.name
      resource_group_name = rule.resource_group_name
      lb_name             = rule.lb_name
      protocol            = rule.probe.protocol # Tcp, Http or Https
      port                = try(rule.probe.port, rule.backend_port)
      request_path        = try(rule.probe.request_path, null)
    }
  ])
}

resource "azurerm_lb_probe" "azlbprobe" {
  for_each = {for probe in local.probes: probe.name => probe}
  
  name                = each.key
  resource_group_name = each.value.resource_group_name
  loadbalancer_id     = azurerm_lb.azlb[each.value.lb_name].id
  protocol            = each.value.protocol
  port                = each.value.port
  request_path        = try(each.value.request_path, null)
}

resource "azurerm_lb_rule" "azlbrule" {
  for_each = {for rule in local.rules: rule.name => rule}
  
  name                           = each.key
  resource_group_name            = each.value.resource_group_name
  loadbalancer_id                = azurerm_lb.azlb[each.value.lb_name].id
  frontend_ip_configuration_name = each.value.fipc_name
  protocol                       = each.value.protocol
  backend_address_pool_id        = azurerm_lb_backend_address_pool.azlbbpool[each.value.backend_pool_name].id
  frontend_port                  = each.value.frontend_port
  backend_port                   = each.value.backend_port
  load_distribution              = each.value.load_distribution
  probe_id                       = azurerm_lb_probe.azlbprobe[each.value.probe.name].id
  # depends_on = [azurerm_marketplace_agreement.accept]
}

locals {
  nics = flatten([
    for bp in local.bps : [
      for nic in bp.nics : {
        name                = nic.name
        resource_group_name = nic.resource_group_name
        lb_name             = bp.lb_name
        ipc_name            = nic.ipc_name
        bp_name             = bp.name
      }
    ]
  ])
}

data "azurerm_network_interface" "nic" {
  for_each = {for nic in local.nics: nic.name => nic}

  name                = each.key
  resource_group_name = each.value.resource_group_name
  depends_on = [var.azlb_depends_on]
}

resource "azurerm_network_interface_backend_address_pool_association" "aznicbpass" {
  for_each = {for nic in local.nics: nic.name => nic}

  network_interface_id    = data.azurerm_network_interface.nic[each.key].id
  ip_configuration_name   = each.value.ipc_name
  backend_address_pool_id = azurerm_lb_backend_address_pool.azlbbpool[each.value.bp_name].id
}