#!/bin/bash

region="us-east-1"
profile="sme-amp-prod"

add_dependency_files() {

echo "Enter the Role ARN which terraform will assume: "
read assume_role
echo "Enter VPC Name which you want to import. ALL LOWER CASE"
read vpc_name

echo '''## Provider Section ##

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.3"
    }
  }
}
''' > provider.tf

echo ""
echo "provider \"aws\" {" >> provider.tf
echo "region = \"${region}\"" >> provider.tf
echo "profile = \"${profile}\"" >> provider.tf
echo "#assume_role {" >> provider.tf
echo "#  role_arn = \"${assume_role}\"" >> provider.tf
echo "  #}" >> provider.tf
echo "}" >> provider.tf

echo "## Backend Section ##" > main.tf

echo "#terraform {" >> main.tf
echo "#  cloud {" >> main.tf
echo "#    organization = \"SMECLOUDOPS\"" >> main.tf

echo "#    workspaces {" >> main.tf
echo "#      name = \"${profile}-${vpc_name}\"" >> main.tf
echo '''#    }
#  }
#}
''' >> main.tf
terraform fmt
}

###VPC imports
vpc_imports() {
  terraform init
  read -p "Enter VPC ID: " vpc_id
  echo resource \"aws_vpc\" \"${vpc_id}\" {} >> tmp-vpc.tf
  terraform import aws_vpc.${vpc_id} ${vpc_id} >/dev/null
  >tmp-vpc.tf
  rm tmp-vpc.tf
  terraformer import aws --resources=vpc --filter=vpc=${vpc_id} --regions ${region} --profile ${profile}
  mv generated/aws/vpc/vpc.tf .
  sed -i 's/tfer--//g' vpc.tf
  rm -rf generated
  sed  -i '/^  enable_classiclink/d' vpc.tf
  sed  -i '/^  ipv6_netmask_length/d' vpc.tf
  echo "Import Successful. Please run terraform plan to verify the changes."
}

### VPC Flow logs
vpc_flow_logs() {
  read -p "Enter VPC ID: " vpc_id
  aws ec2 describe-flow-logs --filter Name=resource-id,Values=${vpc_id} --region ${region} --profile ${profile} | jq -r '.FlowLogs[] | .FlowLogId' > flowlogids.txt
  for id in `cat flowlogids.txt`; do
    echo "resource \"aws_flow_log\" \"${id}-flowlogs\" {}" > tmp-logs.tf
    terraform import aws_flow_log.${id}-flowlogs ${id} > /dev/null
    terraform state show -no-color aws_flow_log.${id}-flowlogs | egrep -v '# aws_flow_log.| arn | id | log_format | log_group_name ' >> vpc-flowlogs.txt
    echo -e "" >> vpc-flowlogs.txt
    >tmp-logs.tf
  done
  mv vpc-flowlogs.txt vpc-flowlogs.tf
  terraform fmt > /dev/null
  rm flowlogids.txt tmp-logs.tf
}

###Subnet imports
subnet_imports() {
  read -p "Enter VPC ID: " vpc_id
  aws ec2 describe-subnets --filters "Name=vpc-id,Values=${vpc_id}" --query "Subnets[*].SubnetId" --region ${region} --profile ${profile} | jq .[]| tr -d '"' > subnet-list.txt
  for subnet in `cat subnet-list.txt`; do
    echo resource \"aws_subnet\" \"${subnet}\" {} >> tmp-subnet.tf
    terraform import aws_subnet.${subnet} ${subnet} >/dev/null
    >tmp-subnet.tf
  done
  rm tmp-subnet.tf
  subnets_list=`sed -e :a -e '/$/N; s/\n/\:/; ta' subnet-list.txt`
  terraformer import aws --resources=subnet --filter=subnet=${subnets_list} --regions=${region} --profile=${profile}
  mv generated/aws/subnet/subnet.tf .
  sed -i 's/tfer--//g' subnet.tf 
  sed  -i '/^  map_customer_owned_ip_on_launch/d' subnet.tf
  rm -rf generated subnet-list.txt
  sed -i s/\"${vpc_id}\"/aws_vpc\.${vpc_id}\.id/g subnet.tf
}

### Internet Gateway imports
igw_imports(){
  read -p "Enter VPC ID: " vpc_id
  aws ec2 describe-internet-gateways --filters "Name=attachment.vpc-id,Values=${vpc_id}" --query "InternetGateways[*].InternetGatewayId" --region=${region} --profile=${profile} | jq .[] | tr -d '"' > igw.txt
  for igw in `cat igw.txt`; do
    echo resource \"aws_internet_gateway\" \"${igw}\" {} >> tmp-igw.tf
    terraform import aws_internet_gateway.${igw} ${igw} >/dev/null
    terraform state show -no-color aws_internet_gateway.${igw} >> igw-tmp.txt
    echo -e "" >> igw-tmp.txt
    >tmp-igw.tf  
  done
  egrep -v "# aws_internet_gateway|timeouts|arn|owner_id| id " igw-tmp.txt > internet-gateway.tf
  rm tmp-igw.tf igw-tmp.txt igw.txt
  sed -i s/\"${vpc_id}\"/aws_vpc\.${vpc_id}\.id/g internet-gateway.tf
  terraform plan
}

nat_imports(){
  read -p "Enter VPC ID: " vpc_id
  export vpc_id="${vpc_id}"
  aws ec2 describe-nat-gateways --region=${region} --profile=${profile} | jq -r '.NatGateways[]| select( .VpcId == env.vpc_id ) | .NatGatewayId' > nat.txt
  for nat in `cat nat.txt`; do
    echo resource \"aws_nat_gateway\" \"${nat}\" {} >> tmp-nat.tf
    terraform import aws_nat_gateway.${nat} ${nat} >/dev/null
    terraform state show -no-color aws_nat_gateway.${nat} >> tmp-nat.txt
    echo -e "" >> tmp-nat.txt
    >tmp-nat.tf 
  done
  egrep -v "# aws_nat_gateway|network_interface_id|private_ip|public_ip| id " tmp-nat.txt > nat-gateway.tf
  rm tmp-nat.tf tmp-nat.txt nat.txt
}

sg_imports(){
  read -p "Enter VPC ID: " vpc_id
  aws ec2 describe-security-groups --filters "Name=vpc-id,Values=${vpc_id}" --region=${region} --profile=${profile} | jq -r '.[] | .[].GroupId' > sg.txt
  for sg in `cat sg.txt`; do
    echo resource \"aws_security_group\" \"${sg}\" {} >> tmp-sg.tf
    terraform import aws_security_group.${sg} ${sg} >/dev/null
    terraform state show -no-color aws_security_group.${sg} >> tmp-sg.txt
    echo -e "" >> tmp-sg.txt
    >tmp-sg.tf
  done
  egrep -v 'owner_id|timeouts|arn|# aws_security_group| id |name_prefix' tmp-sg.txt  > security-groups.tf
  rm sg.txt tmp-sg.tf tmp-sg.txt
}

#####Manual work required after import####
route_table_imports() {
  read -p "Enter VPC ID: " vpc_id
  aws ec2 describe-route-tables --filters "Name=vpc-id,Values=${vpc_id}" --region=${region} --profile=${profile} | jq -r '.[]|.[].RouteTableId' > rt.txt
  table_list=`sed -e :a -e '/$/N; s/\n/\:/; ta' rt.txt`
  terraformer import aws --resources=route_table --filter=route_table=${table_list} --regions=${region} --profile=${profile}
  cd generated/aws/route_table/
  terraform state replace-provider registry.terraform.io/-/aws registry.terraform.io/hashicorp/aws
  sed -i 's/tfer--//g' *
  for i in $(terraform state list); do terraform state mv -state-out="../../../terraform.tfstate" "$i" "$i"; done
  cp route_table.tf route_table_association.tf main_route_table_association.tf ../../../
  cd ../../../
  echo "please fix the ids in route_table_association.tf main_route_table_association.tf files"
  rm -rf rt.txt generated
}

nacl_imports() {
  read -p "Enter VPC ID: " vpc_id
  aws ec2 describe-network-acls --filters "Name=vpc-id,Values=${vpc_id}" --query "NetworkAcls[*].NetworkAclId" --region=${region} --profile=${profile} | jq .[] | tr -d '"' > nacl.txt
  nacl_list=`sed -e :a -e '/$/N; s/\n/\:/; ta' nacl.txt`
  terraformer import aws --resources=nacl --filter=nacl=${nacl_list} --regions=${region} --profile=${profile}
  cd generated/aws/nacl
  terraform state replace-provider registry.terraform.io/-/aws registry.terraform.io/hashicorp/aws
  sed -i 's/tfer--//g' *
  for i in $(terraform state list); do terraform state mv -state-out="../../../terraform.tfstate" "$i" "$i"; done
  cp network_acl.tf ../../../
  cd ../../../
  rm -rf nacl.txt generated
  for file in *_*; do mv "$file" "${file//_/-}"; done
} 

rds_imports() {
  read -p "Enter VPC ID: " vpc_id
  export vpc_id="${vpc_id}"
  aws rds describe-db-instances --region=${region} --profile=${profile} --filters "Name=engine,Values=mysql,postgres,oracle-se2,oracle-ee,sqlserver-ee,sqlserver-se,sqlserver-ex,sqlserver-web,mariadb" | jq --arg vpc_id "$vpc_id" -r '.DBInstances[] | select(.DBSubnetGroup.VpcId == $vpc_id) | .DBInstanceIdentifier' > rds-list.txt
  for rds in `cat rds-list.txt`; do
    echo resource \"aws_db_instance\" \"${rds}\" {} >> tmp-rds.tf
    terraform import aws_db_instance.${rds} ${rds} >/dev/null
    terraform state show -no-color aws_db_instance.${rds} >> tmp-rds.txt
    echo -e "" >> tmp-rds.txt
    >tmp-rds.tf
  done
  egrep -v '# aws_db_instance.| timeouts | status | resource_id | id | hosted_zone_id | engine_version_actual | arn | address | security_group_names | endpoint | latest_restorable_time | name | replicas ' tmp-rds.txt > rds-instances.tf
  rm *.txt tmp-rds.tf
}

aurora_imports() {
  if [ -e aurora-cluster-list.txt ] && [ -f aurora-cluster-list.txt ]; then
    echo "Found aurora-cluster-list.txt file"
    for cluster in `cat aurora-cluster-list.txt`; do
      echo resource \"aws_rds_cluster\" \"${cluster}\" {} >> tmp-cluster.tf
      terraform import aws_rds_cluster.${cluster} ${cluster} > /dev/null
      terraform state show -no-color aws_rds_cluster.${cluster} >> tmp-cluster.txt
      echo -e "" >> tmp-cluster.txt
      >tmp-cluster.tf
      
      # Importing the cluster members
      aws rds describe-db-instances --region=${region} --profile=${profile} --query "DBInstances[?DBClusterIdentifier=='${cluster}'].DBInstanceIdentifier" --output text > aurora_clusters_members.txt

      if [ -f aurora_clusters_members.txt ]; then
        echo "aurora_clusters_members.txt exists"
        for member in `cat aurora_clusters_members.txt`; do
          echo resource \"aws_rds_cluster_instance\" \"${member}\" {} >> tmp-member.tf
          terraform import aws_rds_cluster_instance.${member} ${member} > /dev/null
          terraform state show -no-color aws_rds_cluster_instance.${member} >> tmp-member.txt
          echo -e "" >> tmp-member.txt
          >tmp-member.tf
        done

      else
        echo "aurora_clusters_members.txt file does not exist"
        exit 1
      fi
    done
    egrep -v '# aws_rds_cluster.| arn | engine_version_actual | timeouts | id | hosted_zone_id | reader_endpoint | endpoint | cluster_resource_id ' tmp-cluster.txt >> aurora-clusters.tf
    egrep -v ' timeouts | id | engine_version_actual | endpoint | dbi_resource_id | arn | # aws_rds_cluster_instance.| port | storage_encrypted | writer | network_type | kms_key_id ' tmp-member.txt >> aurora-clusters-members.tf
  else
    echo "aurora-cluster-list.txt does not exist. Please add the list of aurora clusters in the file and run the command again."
    exit 1
  fi
  rm aurora*.txt tmp-*
}

documentdb_imports() {
  terraform init
  read -p "Enter VPC ID: " vpc_id
  export vpc_id="${vpc_id}"
  aws docdb describe-db-instances --region=${region} --profile=${profile} | jq --arg vpc_id "$vpc_id" -r '.DBInstances[] | select(.DBSubnetGroup.VpcId == $vpc_id) | select(.Engine == "docdb") | .DBClusterIdentifier' | uniq > documentdb.txt
  for cluster in `cat documentdb.txt`; do
    #terraform import aws_docdb_cluster.my_cluster my-cluster
    echo resource \"aws_docdb_cluster\" \"${cluster}\" {} >> tmp-cluster.tf
    terraform import aws_docdb_cluster.${cluster} ${cluster} > /dev/null
    terraform state show -no-color aws_docdb_cluster.${cluster} >> tmp-cluster.txt
    echo -e "" >> tmp-cluster.txt
    >tmp-cluster.tf
  done
  egrep -v ' reader_endpoint | endpoint | port | arn | id | hosted_zone_id | cluster_resource_id | timeouts |# aws_docdb_cluster.' tmp-cluster.txt > documentdb-clusters.tf
  rm tmp-cluster.tf tmp-cluster.txt

  for items in `cat documentdb.txt`; do
    aws docdb describe-db-instances --region=${region} --profile=${profile} | jq --arg vpc_id "$vpc_id" -r '.DBInstances[] | select(.DBSubnetGroup.VpcId == $vpc_id) | select(.Engine == "docdb") | .DBInstanceIdentifier' > dbinstances.txt
    for instance in `cat dbinstances.txt`; do
      #terraform import aws_docdb_cluster_instance.my_instance my-instance
      echo resource \"aws_docdb_cluster_instance\" \"${instance}\" {} >> tmp-instance.tf
      terraform import aws_docdb_cluster_instance.${instance} ${instance} > /dev/null
      terraform state show -no-color aws_docdb_cluster_instance.${instance} >> tmp-instance.txt
      echo -e "" >> tmp-instance.txt
      >tmp-instance.tf
    done 
  done
  egrep -v '# aws_docdb_cluster_instance.| arn | dbi_resource_id | endpoint | id | port | timeouts | writer | storage_encrypted | publicly_accessible | preferred_backup_window | kms_key_id | db_subnet_group_name | engine_version ' tmp-instance.txt > documentdb-cluster-instances.tf
  rm tmp-* dbinstances.txt documentdb.txt
}


ec2_imports(){
  read -p "Enter VPC ID: " vpc_id
  aws ec2 describe-instances --filters "Name=vpc-id,Values=$vpc_id" --region=${region} --profile=${profile} | jq -r '.Reservations[].Instances[].InstanceId' > ec2-list.txt
  for instance in `cat ec2-list.txt`; do
    echo "resource \"aws_instance\" \"${instance}\" {}" >> tmp-instance.tf
    terraform import aws_instance.${instance} ${instance} > /dev/null
    echo "resource \"aws_instance\" \"${instance}\" {" >> ec2-instances.txt
    echo "ami = \"`terraform show -json | jq -r --arg instance "$instance" '.values.root_module | .resources[] | select(.type == "aws_instance")| select(.name == $instance) | .values.ami'`\"" >> ec2-instances.txt
    echo "instance_type = \"`terraform show -json | jq -r --arg instance "$instance" '.values.root_module | .resources[] | select(.type == "aws_instance")| select(.name == $instance) | .values.instance_type'`\"" >> ec2-instances.txt
    echo "iam_instance_profile = \"`terraform show -json | jq -r --arg instance "$instance" '.values.root_module | .resources[] | select(.type == "aws_instance")| select(.name == $instance) | .values.iam_instance_profile'`\"" >> ec2-instances.txt
    echo "vpc_security_group_ids = `terraform show -json | jq -r --arg instance "$instance" '.values.root_module | .resources[] | select(.type == "aws_instance")| select(.name == $instance) | .values.vpc_security_group_ids'`" >> ec2-instances.txt
    echo "availability_zone = \"`terraform show -json | jq -r --arg instance "$instance" '.values.root_module | .resources[] | select(.type == "aws_instance")| select(.name == $instance) | .values.availability_zone'`\"" >> ec2-instances.txt
    echo "key_name = \"`terraform show -json | jq -r --arg instance "$instance" '.values.root_module | .resources[] | select(.type == "aws_instance")| select(.name == $instance) | .values.key_name'`\"" >> ec2-instances.txt
    echo "tags = `terraform show -json | jq -r --arg instance "$instance" '.values.root_module | .resources[] | select(.type == "aws_instance")| select(.name == $instance) | .values.tags'`" >> ec2-instances.txt
    echo "lifecycle {
      ignore_changes = [user_data]
    }" >> ec2-instances.txt
    echo "}" >> ec2-instances.txt
    echo -e "" >> ec2-instances.txt
    >tmp-instance.tf
  done
  cat ec2-instances.txt | egrep -v "volume_id|device_name"  > ec2-instances.tf
  terraform fmt
  rm tmp-instance.tf ec2-instances.txt
}

loadbalancers() {
  read -p "Enter VPC ID: " vpc_id
  aws elbv2 describe-load-balancers --query "LoadBalancers[?VpcId=='${vpc_id}'].LoadBalancerArn" --region=${region} --profile=${profile} | jq -r '.[]' > tmp-lbs.txt
  for elb in `cat tmp-lbs.txt`; do
    name=`echo ${elb} | awk -F/ '{print $3}'`
    echo "resource \"aws_lb\" \"${name}\" {}" >> tmp-lbs.tf
    terraform import aws_lb.${name} ${elb} > /dev/null
    terraform state show -no-color aws_lb.${name} >> elbs.txt
    > tmp-lbs.tf
    echo -e "" >> elbs.txt
  done
  egrep -v '# aws_lb| arn | arn_suffix | dns_name | id | zone_id | vpc_id ' elbs.txt > elb.tf
  rm tmp-* elbs.txt
  terraform fmt > /dev/null
}

ebs_imports() {
  for instance in $(terraform state list | grep aws_instance | awk -F. '{print $2}'); do aws ec2 describe-volumes --filters Name=attachment.instance-id,Values=${instance} --query 'Volumes[*].{ID:VolumeId,Device:Attachments[0].Device}' --profile ${profile} --region ${region}; done | jq -r '.[] | .ID' > volume-ids.txt
  for resource in $(terraform state list | grep aws_instance | awk -F. '{print $2}'); do aws ec2 describe-volumes --filters Name=attachment.instance-id,Values=${resource} --query 'Volumes[*].{Instance:Attachments[0].InstanceId,ID:VolumeId,Device:Attachments[0].Device}' --profile ${profile} --region ${region}; done | jq -r '.[]' > volume-data.json

  for volume in `cat volume-ids.txt`; do
    echo "resource \"aws_ebs_volume\" \"${volume}\" {}" > tmp-volume.tf
    terraform import aws_ebs_volume.${volume} ${volume} > /dev/null
    terraform state show -no-color aws_ebs_volume.${volume} >> tmp-volume.txt
    echo "" >> tmp-volume.txt
    > tmp-volume.tf

    ## Attachments
    echo "resource \"aws_volume_attachment\" \"${volume}\" {}" >> tmp-ebs-volume-attachment.tf
    deviceid=`cat volume-data.json| jq -r --arg volume "$volume" '. | select( .ID == $volume ) | .Device'`
    instanceid=`cat volume-data.json| jq -r --arg volume "$volume" '. | select( .ID == $volume ) | .Instance'`
    terraform import aws_volume_attachment.${volume} ${deviceid}:${volume}:${instanceid} > /dev/null
    >tmp-ebs-volume-attachment.tf
    echo "resource \"aws_volume_attachment\" \"${volume}\" {" >> ebs-volume-attachment.txt
    echo "device_name = \"${deviceid}\"" >> ebs-volume-attachment.txt
    echo "volume_id   = aws_ebs_volume.${volume}.id" >> ebs-volume-attachment.txt
    echo "instance_id = aws_instance.${instanceid}.id" >> ebs-volume-attachment.txt
    echo "}" >> ebs-volume-attachment.txt
    echo "" >> ebs-volume-attachment.txt
  done
  egrep -v '# aws_ebs_volume.| arn | id | throughput | timeouts ' tmp-volume.txt > ebs-volumes.tf
  cat ebs-volume-attachment.txt > ebs-volume-attachments.tf
  terraform fmt
  rm tmp-volume.txt volume-data.json ebs-volume-attachment.txt tmp-ebs-volume-attachment.tf tmp-volume.tf volume-ids.txt
}

network_firewall() {
  read -p "Enter VPC ID: " vpc_id
  nfw_name=`aws network-firewall list-firewalls --vpc-ids $vpc_id --region ${region} --profile ${profile} | jq -r '.|.Firewalls[] | .FirewallName'`
  nfw_arn=`aws network-firewall list-firewalls --vpc-ids $vpc_id --region ${region} --profile ${profile} | jq -r '.|.Firewalls[] | .FirewallArn'`
  echo "resource \"aws_networkfirewall_firewall\" \"${nfw_name}\" {}" > nfw-tmp.tf
  terraform import aws_networkfirewall_firewall.${nfw_name} ${nfw_arn} > /dev/null
  rm nfw-tmp.tf
  echo "resource \"aws_networkfirewall_firewall\" \"${nfw_name}\" {" >> network-firewall.txt
  echo "delete_protection = true" >> network-firewall.txt
  echo "description = \"`terraform show -json | jq -r --arg nfw "${nfw_name}" '.values.root_module | .resources[] | select(.type == "aws_networkfirewall_firewall")| select(.name == $nfw) | .values.description'`\"" >> network-firewall.txt
  echo "firewall_policy_arn = \"`terraform show -json | jq -r --arg nfw "${nfw_name}" '.values.root_module | .resources[] | select(.type == "aws_networkfirewall_firewall")| select(.name == $nfw) | .values.firewall_policy_arn'`\"" >> network-firewall.txt
  echo "name = \"`terraform show -json | jq -r --arg nfw "${nfw_name}" '.values.root_module | .resources[] | select(.type == "aws_networkfirewall_firewall")| select(.name == $nfw) | .values.name'`\"" >> network-firewall.txt
  echo "firewall_policy_change_protection = \"`terraform show -json | jq -r --arg nfw "${nfw_name}" '.values.root_module | .resources[] | select(.type == "aws_networkfirewall_firewall")| select(.name == $nfw) | .values.firewall_policy_change_protection'`\"" >> network-firewall.txt
  echo "subnet_change_protection = \"`terraform show -json | jq -r --arg nfw "${nfw_name}" '.values.root_module | .resources[] | select(.type == "aws_networkfirewall_firewall")| select(.name == $nfw) | .values.subnet_change_protection'`\"" >> network-firewall.txt
  echo "vpc_id = \"`terraform show -json | jq -r --arg nfw "${nfw_name}" '.values.root_module | .resources[] | select(.type == "aws_networkfirewall_firewall")| select(.name == $nfw) | .values.vpc_id'`\"" >> network-firewall.txt
  echo "subnet_mapping `terraform show -json | jq -r --arg nfw "${nfw_name}" '.values.root_module | .resources[] | select(.type == "aws_networkfirewall_firewall")| select(.name == $nfw) | .values.subnet_mapping[]' | sed 's/:/=/g' | sed 's/,//g'`" >> network-firewall.txt
  echo "}" >> network-firewall.txt
  sed -i "s/\"ip_address_type\"/ip_address_type/" network-firewall.txt
  sed -i "s/\"subnet_id\"/subnet_id/" network-firewall.txt
  mv network-firewall.txt network-firewall.tf
  terraform fmt > /dev/null
  rm *.txt
  
  #Firewall Policy
  firewall_policy_name=`terraform show -json | jq -r --arg nfw "${nfw_name}" '.values.root_module | .resources[] | select(.type == "aws_networkfirewall_firewall")| select(.name == $nfw) | .values.firewall_policy_arn' | awk -F/ '{print $2}'`
  firewall_policy_arn=`terraform show -json | jq -r --arg nfw "${nfw_name}" '.values.root_module | .resources[] | select(.type == "aws_networkfirewall_firewall")| select(.name == $nfw) | .values.firewall_policy_arn'`
  echo "resource \"aws_networkfirewall_firewall_policy\" \"${firewall_policy_name}\" {}" > network-firewall-policy.tf
  terraform import aws_networkfirewall_firewall_policy.${firewall_policy_name} ${firewall_policy_arn} > /dev/null
  terraform state show -no-color aws_networkfirewall_firewall_policy.${firewall_policy_name} > network-firewall-policy.txt
  egrep -v '# aws_networkfirewall_firewall_policy| arn | id | update_token | priority ' network-firewall-policy.txt > network-firewall-policy.tf
  terraform fmt > /dev/null
  rm network-firewall-policy.txt

  echo "resource \"aws_networkfirewall_logging_configuration\" \"${nfw_name}\" {}" > net-tmp.tf
  terraform import aws_networkfirewall_logging_configuration.${nfw_name} ${nfw_arn} > /dev/null
  echo -e "" >> network-firewall.tf
  rm net-tmp.tf
  terraform state show -no-color aws_networkfirewall_logging_configuration.${nfw_name} | egrep -v '# aws_networkfirewall_logging_configuration| id ' >> network-firewall.tf
  terraform fmt > /dev/null
}

nfw-rg() {
  echo "Enter the stateful rule group ARN. Please rerun the same if you have multiple rule groups. You can find the Rule group arns in network-firewall-policy.tf file"
  read rulegrouparn
  rulegroupname=`echo ${rulegrouparn} | awk -F/ '{print $2}'`
  echo "resource \"aws_networkfirewall_rule_group\" \"${rulegroupname}\" {}" > net-tmp.tf
  terraform import aws_networkfirewall_rule_group.${rulegroupname} ${rulegrouparn} > /dev/null
  rm net-tmp.tf
  terraform state show -no-color aws_networkfirewall_rule_group.${rulegroupname} | egrep -v '# aws_networkfirewall_rule_group| arn | id | update_token ' >> network-firewall-rulegroups.tf
  echo -e "" >> network-firewall-rulegroups.tf 
  terraform fmt > /dev/null
}

batch (){
  read -p "Enter VPC ID: " vpc_id
  aws batch describe-compute-environments --region ${region} --profile ${profile}| jq -r '.computeEnvironments[]| .computeEnvironmentName' > all-batch.txt
  for compute in `cat all-batch.txt`; do
    subnet=`aws batch describe-compute-environments --compute-environments ${compute} --region ${region} --profile ${profile} | jq -r '.computeEnvironments[] | .computeResources.subnets[0]'`
    compute_vpc=`aws ec2 describe-subnets --subnet-ids ${subnet} --query 'Subnets[0].VpcId' | tr -d \"`
    if [ "${vpc_id}" == "${compute_vpc}" ]; then
      echo $compute >> batch.txt
    fi
  done
  rm all-batch.txt
  for compute in `cat batch.txt`; do
    echo "resource \"aws_batch_compute_environment\" \"${compute}\" {}" > tmp-batch.tf
    terraform import aws_batch_compute_environment.${compute} ${compute} > /dev/null
    terraform state show -no-color aws_batch_compute_environment.${compute} | egrep -v '# aws_batch_compute_environment| arn | ecs_cluster_arn | id | status | status_reason ' >> batch-environments.tf
    >tmp-batch.tf
    echo -e "" >> batch-environments.tf
  done
  terraform fmt
  rm batch.txt tmp-batch.tf
}

delete_terraform_resource (){
  read -p "Enter resource type: " resource_type
  # Check if resource file exists
  if [ -f "resources.txt" ]; then
    for item in `cat resources.txt`; do
      terraform state rm ${resource_type}.${item}
    done
  else
    echo "resources.txt file does not exists"
  fi
}

main() {
  local subcommand=${1}
  case ${subcommand} in
    add_dependency)
      add_dependency_files
    ;;
    vpc)
      vpc_imports
    ;;
    flow_logs)
      vpc_flow_logs
    ;;
    subnet)
      subnet_imports
    ;;
    igw)
      igw_imports
    ;;
    nat)
      nat_imports
    ;;
    sg)
      sg_imports
    ;;
    route-table)
      route_table_imports
    ;;
    nacl)
      nacl_imports
    ;;
    rds)
      rds_imports
    ;;
    aurora)
      aurora_imports
    ;;
    documentdb)
      documentdb_imports
    ;;
    ec2)
      ec2_imports
    ;;
    lb)
      loadbalancers
    ;;
    ebs)
      ebs_imports
    ;;
    nfw)
      network_firewall
    ;;
    nfw-rule-group)
      nfw-rg
    ;;
    batch)
      batch
    ;;
    delete_resources_from_state)
      delete_terraform_resource
    ;;
    -h|--help)
      echo "Usage: ./network-importer.sh <subcommand>"
      echo "Available subcommands:"
      echo "  add_dependency"
      echo "  vpc"
      echo "  flow_logs"
      echo "  subnet"
      echo "  igw"
      echo "  nat"
      echo "  sg"
      echo "  route-table"
      echo "  nacl"
      echo "  rds"
      echo "  aurora"
      echo "  documentdb"
      echo "  ec2"
      echo "  lb"
      echo "  ebs"
      echo "  nfw"
      echo "  nfw-rule-group"
      echo "  batch"
      echo "  delete_resources_from_state"
    ;;
    *)
      >&2 echo "ERROR: missing or bad subcommand."
      echo "Usage: ./network-importer.sh -h|--help"
      exit 1
    ;;
  esac
}
main "$@"