resource "aws_cloudwatch_metric_alarm" "ec2-StatusCheckFailed_System" {
  alarm_name                = "${var.settings.StatusCheckFailed_System.ecccode}-EC2_${var.ec2-instance-id}-StatusCheckFailed_System"
  comparison_operator       = var.settings.StatusCheckFailed_System.comparison_operator
  evaluation_periods        = var.settings.StatusCheckFailed_System.evaluation_periods
  metric_name               = "StatusCheckFailed_System"
  period                    = var.settings.StatusCheckFailed_System.period
  statistic                 = var.settings.StatusCheckFailed_System.statistic
  threshold                 = var.settings.StatusCheckFailed_System.threshold
  alarm_description         = "EC2:StatusCheckFailed_System"
  namespace                 = "AWS/EC2"
  insufficient_data_actions = []
  actions_enabled           = var.actions-enabled
  alarm_actions             = [var.settings.StatusCheckFailed_System.action]
  ok_actions                = [var.settings.StatusCheckFailed_System.action]
  dimensions = {
    InstanceId = var.ec2-instance-id
  }
  tags = var.default-tags
}

resource "aws_cloudwatch_metric_alarm" "ec2-StatusCheckFailed_Instance" {
  alarm_name                = "${var.settings.StatusCheckFailed_Instance.ecccode}-EC2_${var.ec2-instance-id}-StatusCheckFailed_Instance"
  comparison_operator       = var.settings.StatusCheckFailed_Instance.comparison_operator
  evaluation_periods        = var.settings.StatusCheckFailed_Instance.evaluation_periods
  metric_name               = "StatusCheckFailed_Instance"
  period                    = var.settings.StatusCheckFailed_Instance.period
  statistic                 = var.settings.StatusCheckFailed_Instance.statistic
  threshold                 = var.settings.StatusCheckFailed_Instance.threshold
  alarm_description         = "EC2:StatusCheckFailed_Instance"
  namespace                 = "AWS/EC2"
  insufficient_data_actions = []
  actions_enabled           = var.actions-enabled
  alarm_actions             = [var.settings.StatusCheckFailed_Instance.action]
  ok_actions                = [var.settings.StatusCheckFailed_Instance.action]
  dimensions = {
    InstanceId = var.ec2-instance-id
  }
  tags = var.default-tags
}

resource "aws_cloudwatch_metric_alarm" "ec2-CPUUtilization" {
  alarm_name                = "${var.settings.CPUUtilization.ecccode}-EC2_${var.ec2-instance-id}-CPUUtilization"
  comparison_operator       = var.settings.CPUUtilization.comparison_operator
  evaluation_periods        = var.settings.CPUUtilization.evaluation_periods
  metric_name               = "CPUUtilization"
  period                    = var.settings.CPUUtilization.period
  statistic                 = var.settings.CPUUtilization.statistic
  threshold                 = var.settings.CPUUtilization.threshold
  alarm_description         = "EC2:CPUUtilization"
  namespace                 = "AWS/EC2"
  insufficient_data_actions = []
  actions_enabled           = var.actions-enabled
  alarm_actions             = [var.settings.CPUUtilization.action]
  ok_actions                = [var.settings.CPUUtilization.action]
  treat_missing_data        = "notBreaching"
  dimensions = {
    InstanceId = var.ec2-instance-id
  }
  tags = var.default-tags
}

# cwagent metrics
data "aws_instance" "ec2-instance" {
  instance_id = var.ec2-instance-id
}

# get instance OS
/*
data "external" "ec2-os" {
  program = ["bash", "${path.module}/get-os-platform.sh"]
  query = {
    input = var.ec2-instance-id
    asrolearn = var.asrolearn
  }
}
*/

module "ec2_os" {
  source            = "../../util/terraform-aws-cli"
  assume_role_arn   = var.asrolearn
  role_session_name = "terraform-ec2-detect-os"
  aws_cli_commands  = ["ec2", "describe-instances", "--instance-ids", var.ec2-instance-id]
  aws_cli_query     = "Reservations[].Instances[].PlatformDetails"
}

# Linux specific checks
# default cw agent uses mem_used_percent metric

resource "aws_cloudwatch_metric_alarm" "ec2-mem_used_percent" {
  # count                     = data.external.ec2-os.result.os == "Linux" ? 1 : 0
  count                     = flatten(module.ec2_os.result)[0] == "Windows" ? 0 : 1
  alarm_name                = "${var.settings.mem_used_percent.ecccode}-EC2_${var.ec2-instance-id}-mem_used_percent"
  comparison_operator       = var.settings.mem_used_percent.comparison_operator
  evaluation_periods        = var.settings.mem_used_percent.evaluation_periods
  metric_name               = "mem_used_percent"
  period                    = var.settings.mem_used_percent.period
  statistic                 = var.settings.mem_used_percent.statistic
  threshold                 = var.settings.mem_used_percent.threshold
  alarm_description         = "EC2:mem_used_percent"
  namespace                 = "CWAgent"
  insufficient_data_actions = []
  actions_enabled           = var.actions-enabled
  alarm_actions             = [var.settings.mem_used_percent.action]
  ok_actions                = [var.settings.mem_used_percent.action]
  dimensions = {
    InstanceId   = var.ec2-instance-id
    ImageId      = data.aws_instance.ec2-instance.ami
    InstanceType = data.aws_instance.ec2-instance.instance_type
  }
  tags = var.default-tags
}

data "external" "cw-dimensions" {
  program = ["bash", "${path.module}/get-cwagent-dimensions.sh"]
  query = {
    input     = var.ec2-instance-id
    asrolearn = var.asrolearn
  }
}

resource "aws_cloudwatch_metric_alarm" "ec2-swap_used_percent" {
  # count                     = data.external.ec2-os.result.os == "Linux" ? 1 : 0
  count                     = flatten(module.ec2_os.result)[0] == "Windows" ? 0 : 1
  alarm_name                = "${var.settings.swap_used_percent.ecccode}-EC2_${var.ec2-instance-id}-swap_used_percent"
  comparison_operator       = var.settings.swap_used_percent.comparison_operator
  evaluation_periods        = var.settings.swap_used_percent.evaluation_periods
  metric_name               = "swap_used_percent"
  period                    = var.settings.swap_used_percent.period
  statistic                 = var.settings.swap_used_percent.statistic
  threshold                 = var.settings.swap_used_percent.threshold
  alarm_description         = "EC2:swap_used_percent"
  namespace                 = "CWAgent"
  insufficient_data_actions = []
  actions_enabled           = var.actions-enabled
  alarm_actions             = [var.settings.swap_used_percent.action]
  ok_actions                = [var.settings.swap_used_percent.action]
  dimensions = {
    InstanceId   = var.ec2-instance-id
    ImageId      = data.aws_instance.ec2-instance.ami
    InstanceType = data.aws_instance.ec2-instance.instance_type
  }
  tags = var.default-tags
}

resource "aws_cloudwatch_metric_alarm" "ec2-disk_used_percent" {
  # count                     = data.external.ec2-os.result.os == "Linux" && data.external.cw-dimensions.result != null ? 1 : 0
  count                     = flatten(module.ec2_os.result)[0] == "Windows" && data.external.cw-dimensions.result != null ? 0 : 1
  alarm_name                = "${var.settings.disk_used_percent.ecccode}-EC2_${var.ec2-instance-id}-disk_used_percent"
  comparison_operator       = var.settings.disk_used_percent.comparison_operator
  evaluation_periods        = var.settings.disk_used_percent.evaluation_periods
  metric_name               = "disk_used_percent"
  period                    = var.settings.disk_used_percent.period
  statistic                 = var.settings.disk_used_percent.statistic
  threshold                 = var.settings.disk_used_percent.threshold
  alarm_description         = "EC2:disk_used_percent"
  namespace                 = "CWAgent"
  insufficient_data_actions = []
  actions_enabled           = var.actions-enabled
  alarm_actions             = [var.settings.disk_used_percent.action]
  ok_actions                = [var.settings.disk_used_percent.action]
  dimensions                = data.external.cw-dimensions.result

  tags = var.default-tags
}


resource "aws_cloudwatch_metric_alarm" "ec2-disk_inodes_free" {
  # count                     = data.external.ec2-os.result.os == "Linux" && data.external.cw-dimensions.result != null ? 1 : 0
  count                     = flatten(module.ec2_os.result)[0] == "Windows" && data.external.cw-dimensions.result != null ? 0 : 1
  alarm_name                = "${var.settings.disk_inodes_free.ecccode}-EC2_${var.ec2-instance-id}-disk_inodes_free"
  comparison_operator       = var.settings.disk_inodes_free.comparison_operator
  evaluation_periods        = var.settings.disk_inodes_free.evaluation_periods
  metric_name               = "disk_inodes_free"
  period                    = var.settings.disk_inodes_free.period
  statistic                 = var.settings.disk_inodes_free.statistic
  threshold                 = var.settings.disk_inodes_free.threshold
  alarm_description         = "EC2:disk_inodes_free"
  namespace                 = "CWAgent"
  insufficient_data_actions = []
  actions_enabled           = var.actions-enabled
  alarm_actions             = [var.settings.disk_inodes_free.action]
  ok_actions                = [var.settings.disk_inodes_free.action]
  dimensions                = data.external.cw-dimensions.result
  /*
  dimensions = {
    InstanceId   = var.ec2-instance-id
    ImageId      = data.aws_instance.ec2-instance.ami
    InstanceType = data.aws_instance.ec2-instance.instance_type
    device       = data.external.disk-device.result.device
    fstype       = data.external.disk-device.result.fstype
    path         = "/"
  }
  */
  tags = var.default-tags
}

# process metric not published by default cw agent config
resource "aws_cloudwatch_metric_alarm" "ec2-processes_total" {
#  count                     = data.external.ec2-os.result.os == "Linux" ? 1 : 0
  count                     = flatten(module.ec2_os.result)[0] == "Windows" ? 0 : 1
  alarm_name                = "${var.settings.processes_total.ecccode}-EC2_${var.ec2-instance-id}-processes_total"
  comparison_operator       = var.settings.processes_total.comparison_operator
  evaluation_periods        = var.settings.processes_total.evaluation_periods
  metric_name               = "processes_total"
  period                    = var.settings.processes_total.period
  statistic                 = var.settings.processes_total.statistic
  threshold                 = var.settings.processes_total.threshold
  alarm_description         = "EC2:processes_total"
  namespace                 = "CWAgent"
  insufficient_data_actions = []
  actions_enabled           = var.actions-enabled
  alarm_actions             = [var.settings.processes_total.action]
  ok_actions                = [var.settings.processes_total.action]
  dimensions = {
    InstanceId   = var.ec2-instance-id
    ImageId      = data.aws_instance.ec2-instance.ami
    InstanceType = data.aws_instance.ec2-instance.instance_type
  }
  tags = var.default-tags
}


# Windows specific checks
resource "aws_cloudwatch_metric_alarm" "ec2-MemoryCommittedPct" {
  # count                     = data.external.ec2-os.result.os == "Windows" ? 1 : 0
  count                     = flatten(module.ec2_os.result)[0] == "Windows" ? 1 : 0
  alarm_name                = "${var.settings.MemoryCommittedPct.ecccode}-EC2_${var.ec2-instance-id}-MemoryCommittedPct"
  comparison_operator       = var.settings.MemoryCommittedPct.comparison_operator
  evaluation_periods        = var.settings.MemoryCommittedPct.evaluation_periods
  metric_name               = "Memory % Committed Bytes In Use"
  period                    = var.settings.MemoryCommittedPct.period
  statistic                 = var.settings.MemoryCommittedPct.statistic
  threshold                 = var.settings.MemoryCommittedPct.threshold
  alarm_description         = "EC2:MemoryCommittedBytes"
  namespace                 = "CWAgent"
  insufficient_data_actions = []
  actions_enabled           = var.actions-enabled
  alarm_actions             = [var.settings.MemoryCommittedPct.action]
  ok_actions                = [var.settings.MemoryCommittedPct.action]
  dimensions = {
    objectname   = "Memory"
    InstanceId   = var.ec2-instance-id
    ImageId      = data.aws_instance.ec2-instance.ami
    InstanceType = data.aws_instance.ec2-instance.instance_type
  }
  tags = var.default-tags
}

resource "aws_cloudwatch_metric_alarm" "ec2-LogicalDiskFreePct" {
  # count                     = data.external.ec2-os.result.os == "Windows" ? 1 : 0
  count                     = flatten(module.ec2_os.result)[0] == "Windows" ? 1 : 0
  alarm_name                = "${var.settings.LogicalDiskFreePct.ecccode}-EC2_${var.ec2-instance-id}-LogicalDiskFreePct"
  comparison_operator       = var.settings.LogicalDiskFreePct.comparison_operator
  evaluation_periods        = var.settings.LogicalDiskFreePct.evaluation_periods
  metric_name               = "LogicalDisk % Free Space"
  period                    = var.settings.LogicalDiskFreePct.period
  statistic                 = var.settings.LogicalDiskFreePct.statistic
  threshold                 = var.settings.LogicalDiskFreePct.threshold
  alarm_description         = "EC2:OsDiskFreePct"
  namespace                 = "CWAgent"
  insufficient_data_actions = []
  actions_enabled           = var.actions-enabled
  alarm_actions             = [var.settings.LogicalDiskFreePct.action]
  ok_actions                = [var.settings.LogicalDiskFreePct.action]
  dimensions = {
    instance     = "C:"
    objectname   = "LogicalDisk"
    InstanceId   = var.ec2-instance-id
    ImageId      = data.aws_instance.ec2-instance.ami
    InstanceType = data.aws_instance.ec2-instance.instance_type
  }
  tags = var.default-tags
}