const std = @import("std");

pub const Fields = struct {
    const HashContext = struct {
        const hash_seed = 1;
        pub fn eql(_: @This(), lhs: []const u8, rhs: []const u8) bool {
            return std.ascii.eqlIgnoreCase(lhs, rhs);
        }
        pub fn hash(_: @This(), s: []const u8) u64 {
            var h = std.hash.Wyhash.init(hash_seed);
            for (s) |ch| {
                const c = [1]u8{std.ascii.toLower(ch)};
                h.update(&c);
            }
            return h.final();
        }
    };

    const HashMap = std.HashMapUnmanaged(
        []const u8,
        []const u8,
        HashContext,
        std.hash_map.default_max_load_percentage,
    );

    unmanaged: HashMap,
    allocator: std.mem.Allocator,

    pub fn init(allocator: std.mem.Allocator) Fields {
        return Fields{
            .unmanaged = .{},
            .allocator = allocator,
        };
    }

    pub fn deinit(self: *Fields) void {
        var hash_iter = self.unmanaged.iterator();
        while (hash_iter.next()) |entry| {
            self.allocator.free(entry.key_ptr.*);
            self.allocator.free(entry.value_ptr.*);
        }

        self.unmanaged.deinit(self.allocator);
    }

    pub fn iterator(self: Fields) HashMap.Iterator {
        return self.unmanaged.iterator();
    }

    pub fn get(self: Fields, key: []const u8) ?[]const u8 {
        return self.unmanaged.get(key);
    }

    pub const ListIterator = struct {
        remaining: []const u8,

        fn extractElement(self: *ListIterator) ?[]const u8 {
            if (self.remaining.len == 0) return null;

            var start: usize = 0;
            var is_quoted = false;
            const end = for (self.remaining) |ch, i| {
                if (start == i and std.ascii.isWhitespace(ch)) {
                    start += 1;
                } else if (ch == '"') {
                    is_quoted = !is_quoted;
                }
                if (ch == ',' and !is_quoted) {
                    break i;
                }
            } else self.remaining.len;

            const str = self.remaining[start..end];
            if (end == self.remaining.len) {
                self.remaining = "";
            } else {
                self.remaining = self.remaining[end + 1 ..];
            }

            return std.mem.trim(u8, str, " \t");
        }

        pub fn next(self: *ListIterator) ?[]const u8 {
            while (self.extractElement()) |elem| {
                if (elem.len != 0) return elem;
            }

            return null;
        }
    };

    pub fn getList(self: Fields, key: []const u8) ?ListIterator {
        return if (self.unmanaged.get(key)) |hdr| ListIterator{ .remaining = hdr } else null;
    }

    pub fn put(self: *Fields, key: []const u8, val: []const u8) !void {
        const key_clone = try self.allocator.alloc(u8, key.len);
        std.mem.copy(u8, key_clone, key);
        errdefer self.allocator.free(key_clone);

        const val_clone = try self.allocator.alloc(u8, val.len);
        std.mem.copy(u8, val_clone, val);
        errdefer self.allocator.free(val_clone);

        if (try self.unmanaged.fetchPut(self.allocator, key_clone, val_clone)) |entry| {
            self.allocator.free(entry.key);
            self.allocator.free(entry.value);
        }
    }

    pub fn append(self: *Fields, key: []const u8, val: []const u8) !void {
        if (self.unmanaged.getEntry(key)) |entry| {
            const new_val = try std.mem.join(self.allocator, ", ", &.{ entry.value_ptr.*, val });
            self.allocator.free(entry.value_ptr.*);
            entry.value_ptr.* = new_val;
        } else {
            try self.put(key, val);
        }
    }

    pub fn count(self: Fields) usize {
        return self.unmanaged.count();
    }
};