import {deserializeTagValue, serializeTagValue} from "./common.impl";
import {HexLengthDelimitedInt} from "./hexLengthDelimitedInt.impl";

export class TagValueArray {
    public static serialize(array: [string, string][]): string {
        let result = '';

        result += HexLengthDelimitedInt.serialize(array.length) + '\n';

        for (let i = 0; i < array.length; i++) {
            const [tag, value] = array[i];
            result += serializeTagValue(tag, value);
        }

        return result;
    }

    static serializeNoLength(tagValueArray: Array<[string, string]>): string {
        let message = '';

        for (const [tag, value] of tagValueArray) {
            message += serializeTagValue(tag, value);
        }

        return message;
    }

    public static serializeLength(array: [string, string][]): number {
        let length = 0;

        length += HexLengthDelimitedInt.serialize(array.length).length + 1; // Add 1 for the newline character

        for (let i = 0; i < array.length; i++) {
            const [tag, value] = array[i];
            length += serializeTagValue(tag, value).length;
        }

        return length;
    }

    private static processTagValuePairs(input: string, count: number, offset: number): Array<[string, string]> {
        const tagValueArray: Array<[string, string]> = [];

        for (let i = 0; i < count; i++) {
            const { tag, value, nextOffset } = deserializeTagValue(input, offset);
            offset = nextOffset;

            tagValueArray.push([tag, value]);

            if (i < count - 1 && input[offset] !== '\n') {
                throw new Error("Invalid input format: missing newline character after tag-value pair");
            }
            offset++;
        }

        return tagValueArray;
    }

    static deserialize(input: string): { array: Array<[string, string]>, nextOffset: number } {
        const countResult = HexLengthDelimitedInt.deserialize(input);
        const count = countResult.number;
        let offset = countResult.nextOffset;

        if (input[offset] !== '\n') {
            throw new Error("Invalid input format: missing newline character after count");
        }
        offset++;

        const array = TagValueArray.processTagValuePairs(input, count, offset);
        return { array, nextOffset: offset };
    }

    static deserializeNoLength(input: string, count: number): Array<[string, string]> {
        return TagValueArray.processTagValuePairs(input, count, 0);
    }

    static isEmpty(tagValueArray: Array<[string, string]>): boolean {
        return tagValueArray.length === 0;
    }

    static hasTag(tagValueArray: Array<[string, string]>, tag: string): boolean {
        return tagValueArray.some(([t, _]) => t === tag);
    }
}