require "exceptions/conflict_exception"
require "providers/base_provider"

module Provider
  # Provider for Amazon EC2
  class Ec2 < BaseProvider

    PROVIDER = "ec2"

    attr_accessor :availability_zone

    def initialize config
      self.certificate_path = config[:aws_certificate]
      self.ssh_key = config[:aws_ssh_key]
      options = {
        :provider => "aws",
        :aws_access_key_id => config[:aws_access_key_id],
        :aws_secret_access_key => config[:aws_secret_access_key]
      }
      if config[:aws_proxy] and config[:aws_no_proxy]
        options[:connection_options] = {
          :proxy => config[:aws_proxy],
          :no_proxy => config[:no_proxy]
        }
      end
      self.connection_options = options
      self.availability_zone = config[:aws_availability_zone] || "us-east-1a"
      self.run_list = config[:aws_integration_run_list] || []
    end

    def configured?
      o = self.connection_options
      super and !(empty_param?(o[:aws_access_key_id]) or empty_param?(o[:aws_secret_access_key]))
    end

    def name
      PROVIDER
    end

    def flavors
      self.compute.flavors.all.map do |f|
        {
          "id" => f.id,
          "cores" => f.cores,
          "disk" => f.disk,
          "name" => f.name,
          "ram" => f.ram
        }
      end
    end

    def groups filters=nil
      buf = {}
      buf = filters.select{|k,v| ["vpc-id"].include?(k)} unless filters.nil?
      g = if buf.empty?
        self.compute.describe_security_groups
      else
        self.compute.describe_security_groups(buf)
      end
      convert_groups(g.body["securityGroupInfo"])
    end

    def images filters
      self.compute.describe_images({"image-id" => filters}).body["imagesSet"].map do |i|
        {
          "id" => i["imageId"],
          "name" => i["name"],
          "status" => i["imageState"]
        }
      end
    end

    def networks_detail
      self.networks
    end

    def networks
      self.compute.describe_subnets.body["subnetSet"].select{|n| n["state"] == "available"}.map do |n|
        {
          "cidr" => n["cidrBlock"],
          "vpcId" => n["vpcId"],
          "subnetId" => n["subnetId"],
          "name" => n["subnetId"],
          "zone" => n["availabilityZone"]
        }
      end
    end

    def servers
      list = self.compute.describe_instances.body["reservationSet"]
      list.select{|l| l["instancesSet"][0]["instanceState"]["name"].to_s != "terminated"}.map do |server|
        convert_server server["instancesSet"][0]
      end
    end

    def server id
      list = self.compute.describe_instances('instance-id' => [id]).body["reservationSet"]
      convert_server list[0]["instancesSet"][0]
    end

    def create_server s, image, flavor, subnets, groups, out, options={}
      out << "Creating server for project '#{s.project} - #{s.deploy_env}'\n"
      options = {
        "InstanceType" => flavor,
#        "Placement.AvailabilityZone" => s.options[:availability_zone],
        "KeyName" => self.ssh_key
      }
      vpcId = nil
      unless subnets.empty?
        options["SubnetId"] = subnets[0]
        vpcId = self.networks.detect{|n| n["name"] == options["SubnetId"]}["vpcId"]
        if vpcId.nil?
          out << "Can not get 'vpcId' by subnet name '#{options["SubnetId"]}'\n"
          return false
        end
      end
      options["SecurityGroupId"] = extract_group_ids(groups, vpcId).join(",")

      aws_server = nil
      compute = self.compute
      begin
        aws_server = compute.run_instances(image, 1, 1, options)
      rescue Excon::Errors::Unauthorized => ue
        #root = XML::Parser.string(ue.response.body).parse.root
        #msg = root.children.find { |node| node.name == "Message" }
        #code = root.children.find { |node| node.name == "Code" }
        code = "TODO"
        msg = ue.response.body
        out << "\nERROR: Unauthorized (#{code}: #{msg})"
        return false
      rescue Fog::Compute::AWS::Error => e
        out << e.message
        return false
      end

      abody = aws_server.body
      instance = abody["instancesSet"][0]
      s.id = instance["instanceId"]

      out << "\nWaiting for server..."

      details, state = nil, instance["instanceState"]["name"]
      until state == "running"
        sleep(2)
        details = compute.describe_instances("instance-id" => [s.id]).body["reservationSet"][0]["instancesSet"][0]
        state = details["instanceState"]["name"].to_s
        next if state == "pending" or state == "running"
        out << "Server returns state '#{state}'"
        return false
      end
      s.public_ip = details["ipAddress"]
      s.private_ip = details["privateIpAddress"]
      compute.create_tags(s.id, {"Name" => s.chef_node_name})
      out << "\nDone\n\n"
      out << s.info

      true
    end

    def delete_server s
      r = self.compute.terminate_instances(s.id)
      i = r.body["instancesSet"][0]
      old_state = i["previousState"]["name"]
      state = i["currentState"]["name"]
      return r.status == 200 ? "Server with id '#{s.id}' changed state '#{old_state}' to '#{state}'" : r.body
    end

    def pause_server s
      es = self.server s.id
      if es["state"] == "running"
        self.compute.stop_instances [ s.id ]
        return nil
      else
        return es["state"]
      end
    end

    def unpause_server s
      es = self.server s.id
      if es["state"] == "stopped"
        self.compute.start_instances [ s.id ]
        return nil
      else
        return es["state"]
      end
    end

    def set_tags instance_id, tags
      raise ConflictException.new("You can not change 'Name' tag") if tags.key?("Name")
      compute.create_tags(instance_id, tags)
    end

    def unset_tags instance_id, tags
      raise ConflictException.new("You can not change 'Name' tag") if tags.key?("Name")
      compute.delete_tags(instance_id, tags)
    end

    def compute
      connection_compute(connection_options)
    end

    def cloud_formation
     @cloud_formation ||= Fog::AWS::CloudFormation.new(connection_options)
    end

    def create_stack(stack, out)
      begin
        out << "Creating stack for project '#{stack.project}' and environment '#{stack.deploy_env}'...\n"
        stack.name = create_default_stack_name(stack) unless stack.name
        out << "Stack name: #{stack.name}\n"
        out << "Stack template: #{stack.stack_template}\n"
        out << "Stack parameters: #{stack.parameters}\n"
        out << "Stack template: #{stack.template_body}\n"
        response = cloud_formation.create_stack(stack.name,
          {
            'TemplateBody' => stack.template_body,
            'Parameters' => stack.parameters || {}
          }
        )
        stack.id = response.body['StackId']
      rescue Excon::Errors::Conflict => e
        raise ProviderErrors::NameConflict
      rescue Excon::Errors::BadRequest => br
        response = ::Chef::JSONCompat.from_json(br.response.body)
        if response['code'] == 400
          out << "\nERROR: Bad request (400): #{response['explanation']}"
          out << "\n"
          raise InvalidRecord.new(response['explanation'])
        else
          out << "\nERROR: Unknown server error (#{response['code']}): #{response['explanation']}"
          out << "\n"
          raise InvalidRecord.new(response['explanation'])
        end
      end
    end

    def delete_stack(stack)
      fog_stack(stack).destroy
    end

    def stack_details(stack)
      fog_stack(stack).details
    end

    def stack_resources(stack)
      fog_stack(stack).resources
    end

    def stack_resource(stack, resource_id)
      physical_id = fog_stack(stack).resources.get(resource_id).physical_resource_id
      compute.servers.get(physical_id)
    end

    def stack_servers(stack)
      fog_stack(stack).resources.map{|r| compute.servers.get(r.physical_resource_id)}
    end

  private
    def convert_groups list
      res = {}
      list.each do |g|
        next if g["groupName"].nil?
        res[g["groupName"]] = {
          "description" => g["groupDescription"],
          "id" => g["groupId"]
        }
        rules = []
        g["ipPermissions"].each do |r|
          cidr = r["ipRanges"][0] || {}
          rules.push({
            "protocol" => r["ipProtocol"],
            "from" => r["fromPort"],
            "to" => r["toPort"],
            "cidr" => cidr["cidrIp"]
          })
        end
        res[g["groupName"]]["rules"] = rules
      end
      res
    end

    def convert_server s
      {
        "state" => s["instanceState"]["name"],
        "name" => s["tagSet"]["Name"],
        "image" => s["imageId"],
        "flavor" => s["instanceType"],
        "keypair" => s["keyName"],
        "instance_id" => s["instanceId"],
        "dns_name" => s["dnsName"],
        "zone" => s["placement"]["availabilityZone"],
        "private_ip" => s["privateIpAddress"],
        "public_ip" => s["ipAddress"],
        "launched_at" => s["launchTime"]
      }
    end

    def extract_group_ids names, vpcId
      return [] if names.nil?
      p = nil
      p = {"vpc-id" => vpcId} unless vpcId.nil?
      groups = self.groups(p)
      r = names.map do |name|
        groups[name]["id"]
      end
      r
    end

    def fog_stack(stack)
      cloud_formation.stacks.get(stack.name, stack.id)
    end
  end
end