import { Encoder, EncoderState } from "./encoder";
import { Decoder, DecoderState } from "./decoder";
import type { Value } from "./values";
import { strip } from "./strip";

export type PointerType<T> = {
    decode(s: DecoderState): T;
    encode(s: EncoderState, v: T): void;

    fromValue(v: Value<GenericPointer>): T;
    toValue(v: T): Value<GenericPointer>;
}

export class Pointer<T> {
    embeddedValue: T;

    constructor(embeddedValue: T) {
        this.embeddedValue = embeddedValue;
    }

    equals(other: any, is: (a: any, b: any) => boolean) {
        return isPointer<T>(other) && is(this.embeddedValue, other.embeddedValue);
    }

    asPreservesText(): string {
        return '#!' + (this.embeddedValue as any).asPreservesText();
    }
}

export function embed<T>(embeddedValue: T): Pointer<T> {
    return new Pointer(embeddedValue);
}

export function isPointer<T>(v: Value<T>): v is Pointer<T> {
    return typeof v === 'object' && 'embeddedValue' in v;
}

export class GenericPointer {
    generic: Value;

    constructor(generic: Value) {
        this.generic = generic;
    }

    equals(other: any, is: (a: any, b: any) => boolean) {
        return typeof other === 'object' && 'generic' in other && is(this.generic, other.generic);
    }

    asPreservesText(): string {
        return this.generic.asPreservesText();
    }
}

export const genericPointerType: PointerType<GenericPointer> = {
    decode(s: DecoderState): GenericPointer {
        return new GenericPointer(new Decoder(s, this).next());
    },

    encode(s: EncoderState, v: GenericPointer): void {
        new Encoder(s, this).push(v.generic);
    },

    fromValue(v: Value<GenericPointer>): GenericPointer {
        return new GenericPointer(strip(v));
    },

    toValue(v: GenericPointer): Value<GenericPointer> {
        return v.generic;
    }
};

export const neverPointerType: PointerType<never> = {
    decode(_s: DecoderState): never {
        throw new Error("Pointers not permitted at this point in Preserves document");
    },

    encode(_s: EncoderState, _v: never): void {
        throw new Error("Pointers not permitted encoding Preserves document");
    },

    fromValue(_v: Value<GenericPointer>): never {
        throw new Error("Pointers not permitted at this point in Preserves document");
    },

    toValue(_v: never): Value<GenericPointer> {
        throw new Error("Pointers not permitted encoding Preserves document");
    }
};

let _nextId = 0;
const _registry = new WeakMap<object, number>();
export function pointerId(v: any): number {
    let id = _registry.get(v);
    if (id === void 0) {
        id = _nextId++;
        _registry.set(v, id);
    }
    return id;
}

export const identityPointerType: PointerType<any> = {
    decode(_s: DecoderState): any {
        throw new Error("Cannot decode identityPointerType");
    },

    encode(s: EncoderState, v: any): void {
        new Encoder(s, this).push(pointerId(v));
    },

    fromValue(_v: Value<GenericPointer>): any {
        throw new Error("Cannot decode identityPointerType");
    },

    toValue(v: any): Value<GenericPointer> {
        return pointerId(v);
    }
};