// Copyright (c) 2019-2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module s3

// list returns up to ~1000 objects matching `opts`. Use the returned
// `next_continuation_token` to page through more.
//
// Speaks the ListObjectsV2 protocol.
pub fn (c &Client) list(opts ListOptions) !ListResult {
	bucket := pick_bucket(c.credentials, opts.bucket)!
	creds := c.creds_for(bucket)
	path := bucket_path(creds, bucket)
	mut q := map[string]string{}
	q['list-type'] = '2'
	if opts.prefix != '' {
		q['prefix'] = opts.prefix
	}
	if opts.continuation_token != '' {
		q['continuation-token'] = opts.continuation_token
	}
	if opts.delimiter != '' {
		q['delimiter'] = opts.delimiter
	}
	if opts.max_keys > 0 {
		q['max-keys'] = opts.max_keys.str()
	}
	if opts.start_after != '' {
		q['start-after'] = opts.start_after
	}
	if opts.encoding_type != '' {
		q['encoding-type'] = opts.encoding_type
	}
	if opts.fetch_owner {
		q['fetch-owner'] = 'true'
	}
	query := canonical_query_string(q)
	signed := sign_request(creds, SignRequest{
		method:       'GET'
		path:         path
		query:        query
		payload_hash: empty_sha256
	})!
	resp := c.do_http(signed, '')!
	if resp.status_code != 200 {
		return new_http_error(resp.status_code, bucket, resp.body)
	}
	return parse_list_response(resp.body)
}

// parse_list_response is hand-rolled XML extraction. ListObjectsV2 uses a
// rigid structure with no attributes we care about, so a tag scanner beats
// pulling in the full XML decoder both in code size and predictability
// against malformed input.
pub fn parse_list_response(body string) !ListResult {
	objects := parse_contents(body)
	common := parse_common_prefixes(body)
	max_keys := extract_xml_tag(body, 'MaxKeys').int()
	key_count := extract_xml_tag(body, 'KeyCount').int()
	is_truncated := extract_xml_tag(body, 'IsTruncated') == 'true'
	return ListResult{
		name:                    extract_xml_tag(body, 'Name')
		prefix:                  extract_xml_tag(body, 'Prefix')
		delimiter:               extract_xml_tag(body, 'Delimiter')
		start_after:             extract_xml_tag(body, 'StartAfter')
		max_keys:                max_keys
		key_count:               key_count
		is_truncated:            is_truncated
		continuation_token:      extract_xml_tag(body, 'ContinuationToken')
		next_continuation_token: extract_xml_tag(body, 'NextContinuationToken')
		objects:                 objects
		common_prefixes:         common
	}
}

fn parse_contents(body string) []ObjectInfo {
	mut out := []ObjectInfo{}
	mut start := 0
	for {
		open := body.index_after('<Contents>', start) or { break }
		close := body.index_after('</Contents>', open) or { break }
		seg := body[open + '<Contents>'.len..close]
		mut owner := ?Owner(none)
		owner_open := seg.index('<Owner>') or { -1 }
		if owner_open >= 0 {
			owner_close := seg.index('</Owner>') or { -1 }
			if owner_close > owner_open {
				owner_seg := seg[owner_open + '<Owner>'.len..owner_close]
				owner = Owner{
					id:           extract_xml_tag(owner_seg, 'ID')
					display_name: extract_xml_tag(owner_seg, 'DisplayName')
				}
			}
		}
		out << ObjectInfo{
			key:           extract_xml_tag(seg, 'Key')
			last_modified: extract_xml_tag(seg, 'LastModified')
			etag:          extract_xml_tag(seg, 'ETag').trim('"')
			size:          extract_xml_tag(seg, 'Size').i64()
			storage_class: extract_xml_tag(seg, 'StorageClass')
			owner:         owner
		}
		start = close + '</Contents>'.len
	}
	return out
}

fn parse_common_prefixes(body string) []CommonPrefix {
	mut out := []CommonPrefix{}
	mut start := 0
	for {
		open := body.index_after('<CommonPrefixes>', start) or { break }
		close := body.index_after('</CommonPrefixes>', open) or { break }
		seg := body[open + '<CommonPrefixes>'.len..close]
		out << CommonPrefix{
			prefix: extract_xml_tag(seg, 'Prefix')
		}
		start = close + '</CommonPrefixes>'.len
	}
	return out
}