    # File lib/fog/aws/requests/compute/describe_instances.rb, line 82
            def describe_instances(filters = {})
              unless filters.is_a?(Hash)
                Fog::Logger.deprecation("describe_instances with #{filters.class} param is deprecated, use describe_instances('instance-id' => []) instead [light_black](#{caller.first})[/]")
                filters = {'instance-id' => [*filters]}
              end

              response = Excon::Response.new

              instance_set = self.data[:instances].values
              instance_set = apply_tag_filters(instance_set, filters, 'instanceId')

              aliases = {
                'architecture'      => 'architecture',
                'availability-zone' => 'availabilityZone',
                'client-token'      => 'clientToken',
                'dns-name'         => 'dnsName',
                'group-id'          => 'groupId',
                'image-id'          => 'imageId',
                'instance-id'       => 'instanceId',
                'instance-lifecycle'  => 'instanceLifecycle',
                'instance-type'     => 'instanceType',
                'ip-address'        => 'ipAddress',
                'kernel-id'         => 'kernelId',
                'key-name'          => 'key-name',
                'launch-index'      => 'launchIndex',
                'launch-time'       => 'launchTime',
                'monitoring-state'  => 'monitoringState',
                'owner-id'          => 'ownerId',
                'placement-group-name' => 'placementGroupName',
                'platform'          => 'platform',
                'private-dns-name'  => 'privateDnsName',
                'private-ip-address'  => 'privateIpAddress',
                'product-code'      => 'productCode',
                'ramdisk-id'        => 'ramdiskId',
                'reason'            => 'reason',
                'requester-id'      => 'requesterId',
                'reservation-id'    => 'reservationId',
                'root-device-name'  => 'rootDeviceName',
                'root-device-type'  => 'rootDeviceType',
                'spot-instance-request-id' => 'spotInstanceRequestId',
                'subnet-id'         => 'subnetId',
                'virtualization-type' => 'virtualizationType',
                'vpc-id'            => 'vpcId'
              }
              block_device_mapping_aliases = {
                'attach-time'           => 'attachTime',
                'delete-on-termination' => 'deleteOnTermination',
                'device-name'           => 'deviceName',
                'status'                => 'status',
                'volume-id'             => 'volumeId',
              }
              instance_state_aliases = {
                'code' => 'code',
                'name' => 'name'
              }
              state_reason_aliases = {
                'code'    => 'code',
                'message' => 'message'
              }
              for filter_key, filter_value in filters
                if block_device_mapping_key = filter_key.split('block-device-mapping.')[1]
                  aliased_key = block_device_mapping_aliases[block_device_mapping_key]
                  instance_set = instance_set.reject{|instance| !instance['blockDeviceMapping'].detect {|block_device_mapping| [*filter_value].include?(block_device_mapping[aliased_key])}}
                elsif instance_state_key = filter_key.split('instance-state-')[1]
                  aliased_key = instance_state_aliases[instance_state_key]
                  instance_set = instance_set.reject{|instance| ![*filter_value].include?(instance['instanceState'][aliased_key])}
                elsif state_reason_key = filter_key.split('state-reason-')[1]
                  aliased_key = state_reason_aliases[state_reason_key]
                  instance_set = instance_set.reject{|instance| ![*filter_value].include?(instance['stateReason'][aliased_key])}
                elsif filter_key == "group-name"
                  instance_set = instance_set.reject {|instance| !instance['groupSet'].include?(filter_value)}
                else
                  aliased_key = aliases[filter_key]
                  instance_set = instance_set.reject {|instance| ![*filter_value].include?(instance[aliased_key])}
                end
              end

              brand_new_instances = instance_set.find_all do |instance|
                instance['instanceState']['name'] == 'pending' &&
                  Time.now - instance['launchTime'] < Fog::Mock.delay * 2
              end

              # Error if filtering for a brand new instance directly
              if (filters['instance-id'] || filters['instanceId']) && !brand_new_instances.empty?
                raise Fog::Compute::AWS::NotFound.new("The instance ID '#{brand_new_instances.first['instanceId']}' does not exist")
              end

              # Otherwise don't include it in the list
              instance_set = instance_set.reject {|instance| brand_new_instances.include?(instance) }

              response.status = 200
              reservation_set = {}

              instance_set.each do |instance|
                case instance['instanceState']['name']
                when 'pending'
                  if Time.now - instance['launchTime'] >= Fog::Mock.delay * 2
                    instance['ipAddress']         = Fog::AWS::Mock.ip_address
                    instance['originalIpAddress'] = instance['ipAddress']
                    instance['dnsName']           = Fog::AWS::Mock.dns_name_for(instance['ipAddress'])
                    instance['privateIpAddress']  = Fog::AWS::Mock.private_ip_address
                    instance['privateDnsName']    = Fog::AWS::Mock.private_dns_name_for(instance['privateIpAddress'])
                    instance['instanceState']     = { 'code' => 16, 'name' => 'running' }
                  end
                when 'rebooting'
                  instance['instanceState'] = { 'code' => 16, 'name' => 'running' }
                when 'stopping'
                  instance['instanceState'] = { 'code' => 0, 'name' => 'stopping' }
                  instance['stateReason'] = { 'code' => 0 }
                when 'shutting-down'
                  if Time.now - self.data[:deleted_at][instance['instanceId']] >= Fog::Mock.delay * 2
                    self.data[:deleted_at].delete(instance['instanceId'])
                    self.data[:instances].delete(instance['instanceId'])
                  elsif Time.now - self.data[:deleted_at][instance['instanceId']] >= Fog::Mock.delay
                    instance['instanceState'] = { 'code' => 48, 'name' => 'terminating' }
                  end
                when 'terminating'
                  if Time.now - self.data[:deleted_at][instance['instanceId']] >= Fog::Mock.delay
                    self.data[:deleted_at].delete(instance['instanceId'])
                    self.data[:instances].delete(instance['instanceId'])
                  end
                end

                if self.data[:instances][instance['instanceId']]

                  reservation_set[instance['reservationId']] ||= {
                    'groupSet'      => instance['groupSet'],
                    'instancesSet'  => [],
                    'ownerId'       => instance['ownerId'],
                    'reservationId' => instance['reservationId']
                  }
                  reservation_set[instance['reservationId']]['instancesSet'] << instance.reject{|key,value| !['amiLaunchIndex', 'architecture', 'blockDeviceMapping', 'clientToken', 'dnsName', 'imageId', 'instanceId', 'instanceState', 'instanceType', 'ipAddress', 'kernelId', 'keyName', 'launchTime', 'monitoring', 'placement', 'platform', 'privateDnsName', 'privateIpAddress', 'productCodes', 'ramdiskId', 'reason', 'rootDeviceType', 'stateReason'].include?(key)}.merge('tagSet' => self.data[:tag_sets][instance['instanceId']])
                end
              end

              response.body = {
                'requestId'       => Fog::AWS::Mock.request_id,
                'reservationSet' => reservation_set.values
              }
              response
            end