# frozen_string_literal: true

module Meroku
  # Mostly wrappers around aws library functions
  module Aws
    include Meroku::Shared

    def default_instance_params
      {
        image_id: 'ami-841f46ff',
        min_count: 1,
        max_count: 1,
        key_name: 'meroku.id_rsa',
        instance_type: 't2.micro',
        tag_specifications: [tag]
      }
    end

    def make_instance
      @instance_id =
        Meroku::Shared \
        .ec2_client  \
        .run_instances(default_instance_params) \
        .instances.fetch(0).instance_id
      puts 'waiting'
      Meroku::Shared.ec2_client.wait_until(
        :instance_running,
        instance_ids: [@instance_id]
      )
    end

    def associate_address
      Meroku::Shared.ec2_client.associate_address(
        allocation_id: allocation_id, instance_id: instance_id
      )
    end

    # Private S3 Bucket
    # The only security here is not no one knows the bucket name,
    # which is a uuid
    def bucket
      "http://s3.amazonaws.com/#{Meroku::Shared.secrets.meroku_secret}/"
    end

    def self.terminate_all(tag: nil)
      Meroku::Shared.ec2_client.describe_instances(
        filters: running_filter(tag)
      ).reservations.map do |r|
        id = r.instances.first.instance_id
        puts "Will terminate #{id}"
        Meroku::Shared.ec2_client.terminate_instances(instance_ids: [id])
      end
    end

    # Our elastic ip allocation
    def allocation_id
      'eipalloc-139f7823'
    end

    def ip_address
      '34.239.241.218'
    end

    def tag
      {
        resource_type: 'instance',
        tags: [
          {
            key: 'Name',
            value: 'node'
          }
        ]
      }
    end

    def self.running_filter(tag)
      [
        { name: 'tag:Name', values: [tag] },
        { name: 'instance-state-name', values: %w[running pending] }
      ]
    end
  end
end