// Preserves Binary codec.

import {
    underlying,
    Annotated,
    Dictionary, Set, Bytes, Record, Single, Double,
    BytesLike,
    Value,
} from './values';
import { Tag } from './constants';

import { PreserveOn } from './symbols';

export type ErrorType = 'DecodeError' | 'EncodeError' | 'ShortPacket';

export function isCodecError(e: any, t?: ErrorType): e is PreservesCodecError {
    return typeof e === 'object' && e !== null &&
        '_codecErrorType' in e &&
        (!t || e._codecErrorType() === t);
}

export const isDecodeError = (e: any): e is DecodeError => isCodecError(e, 'DecodeError');
export const isEncodeError = (e: any): e is EncodeError => isCodecError(e, 'EncodeError');
export const isShortPacket = (e: any): e is ShortPacket => isCodecError(e, 'ShortPacket');

export abstract class PreservesCodecError {
    abstract _codecErrorType(): ErrorType;
}

export class DecodeError extends Error {
    _codecErrorType(): ErrorType { return 'DecodeError' }
}

export class EncodeError extends Error {
    _codecErrorType(): ErrorType { return 'EncodeError' }

    readonly irritant: any;

    constructor(message: string, irritant: any) {
        super(message);
        this.irritant = irritant;
    }
}

export class ShortPacket extends DecodeError {
    _codecErrorType(): ErrorType { return 'ShortPacket' }
}

export interface DecoderOptions {
    includeAnnotations?: boolean;
}

export class Decoder {
    packet: Uint8Array;
    index: number;
    options: DecoderOptions;

    constructor(packet: BytesLike = new Uint8Array(0), options: DecoderOptions = {}) {
        this.packet = underlying(packet);
        this.index = 0;
        this.options = options;
    }

    get includeAnnotations(): boolean {
        return this.options.includeAnnotations ?? false;
    }

    write(data: BytesLike) {
        this.packet = Bytes.concat([this.packet.slice(this.index), data])._view;
        this.index = 0;
    }

    nextbyte(): number {
        if (this.index >= this.packet.length) throw new ShortPacket("Short packet");
        // ^ NOTE: greater-than-or-equal-to, not greater-than.
        return this.packet[this.index++];
    }

    nextbytes(n: number): DataView {
        const start = this.index;
        this.index += n;
        if (this.index > this.packet.length) throw new ShortPacket("Short packet");
        // ^ NOTE: greater-than, not greater-than-or-equal-to.
        return new DataView(this.packet.buffer, this.packet.byteOffset + start, n);
    }

    varint(): number {
        // TODO: Bignums :-/
        const v = this.nextbyte();
        if (v < 128) return v;
        return (this.varint() << 7) + (v - 128);
    }

    peekend(): boolean {
        const matched = this.nextbyte() === Tag.End;
        if (!matched) this.index--;
        return matched;
    }

    nextvalues(): Value[] {
        const result = [];
        while (!this.peekend()) result.push(this.next());
        return result;
    }

    nextint(n: number): number {
        // TODO: Bignums :-/
        if (n === 0) return 0;
        let acc = this.nextbyte();
        if (acc & 0x80) acc -= 256;
        for (let i = 1; i < n; i++) acc = (acc << 8) | this.nextbyte();
        return acc;
    }

    wrap(v: Value): Value {
        return this.includeAnnotations ? new Annotated(v) : v;
    }

    static dictionaryFromArray(vs: Value[]): Dictionary<Value> {
        const d = new Dictionary<Value>();
        if (vs.length % 2) throw new DecodeError("Missing dictionary value");
        for (let i = 0; i < vs.length; i += 2) {
            d.set(vs[i], vs[i+1]);
        }
        return d;
    }

    unshiftAnnotation(a: Value, v: Annotated) {
        if (this.includeAnnotations) {
            v.annotations.unshift(a);
        }
        return v;
    }

    next(): Value {
        const tag = this.nextbyte();
        switch (tag) {
            case Tag.False: return this.wrap(false);
            case Tag.True: return this.wrap(true);
            case Tag.Float: return this.wrap(new Single(this.nextbytes(4).getFloat32(0, false)));
            case Tag.Double: return this.wrap(new Double(this.nextbytes(8).getFloat64(0, false)));
            case Tag.End: throw new DecodeError("Unexpected Compound end marker");
            case Tag.Annotation: {
                const a = this.next();
                const v = this.next() as Annotated;
                return this.unshiftAnnotation(a, v);
            }
            case Tag.SignedInteger: return this.wrap(this.nextint(this.varint()));
            case Tag.String: return this.wrap(Bytes.from(this.nextbytes(this.varint())).fromUtf8());
            case Tag.ByteString: return this.wrap(Bytes.from(this.nextbytes(this.varint())));
            case Tag.Symbol: return this.wrap(Symbol.for(Bytes.from(this.nextbytes(this.varint())).fromUtf8()));
            case Tag.Record: {
                const vs = this.nextvalues();
                if (vs.length === 0) throw new DecodeError("Too few elements in encoded record");
                return this.wrap(new Record(vs[0], vs.slice(1)));
            }
            case Tag.Sequence: return this.wrap(this.nextvalues());
            case Tag.Set: return this.wrap(new Set(this.nextvalues()));
            case Tag.Dictionary: return this.wrap(Decoder.dictionaryFromArray(this.nextvalues()));
            default: {
                if (tag >= Tag.SmallInteger_lo && tag <= Tag.SmallInteger_lo + 15) {
                    const v = tag - Tag.SmallInteger_lo;
                    return this.wrap(v > 12 ? v - 16 : v);
                }
                if (tag >= Tag.MediumInteger_lo && tag <= Tag.MediumInteger_lo + 15) {
                    const n = tag - Tag.MediumInteger_lo;
                    return this.wrap(this.nextint(n + 1));
                }
                throw new DecodeError("Unsupported Preserves tag: " + tag);
            }
        }
    }

    try_next() {
        const start = this.index;
        try {
            return this.next();
        } catch (e) {
            if (e instanceof ShortPacket) {
                this.index = start;
                return void 0;
            }
            throw e;
        }
    }
}

export function decode(bs: BytesLike, options?: DecoderOptions) {
    return new Decoder(bs, options).next();
}

export function decodeWithAnnotations(bs: BytesLike, options: DecoderOptions = {}): Annotated {
    return decode(bs, { ... options, includeAnnotations: true }) as Annotated;
}

export interface EncoderOptions {
    canonical?: boolean;
    includeAnnotations?: boolean;
}

export class Encoder {
    chunks: Array<Uint8Array>;
    view: DataView;
    index: number;
    options: EncoderOptions;

    constructor(options: EncoderOptions = {}) {
        this.chunks = [];
        this.view = new DataView(new ArrayBuffer(256));
        this.index = 0;
        this.options = options;
    }

    get canonical(): boolean {
        return this.options.canonical ?? true;
    }

    get includeAnnotations(): boolean {
        return this.options.includeAnnotations ?? !this.canonical;
    }

    contents(): Bytes {
        this.rotatebuffer(4096);
        return Bytes.concat(this.chunks);
    }

    rotatebuffer(size: number) {
        this.chunks.push(new Uint8Array(this.view.buffer, 0, this.index));
        this.view = new DataView(new ArrayBuffer(size));
        this.index = 0;
    }

    makeroom(amount: number) {
        if (this.index + amount > this.view.byteLength) {
            this.rotatebuffer(amount + 4096);
        }
    }

    emitbyte(b: number) {
        this.makeroom(1);
        this.view.setUint8(this.index++, b);
    }

    emitbytes(bs: Uint8Array) {
        this.makeroom(bs.length);
        (new Uint8Array(this.view.buffer)).set(bs, this.index);
        this.index += bs.length;
    }

    varint(v: number) {
        while (v >= 128) {
            this.emitbyte((v % 128) + 128);
            v = Math.floor(v / 128);
        }
        this.emitbyte(v);
    }

    encodeint(v: number) {
        // TODO: Bignums :-/
        const plain_bitcount = Math.floor(Math.log2(v > 0 ? v : ~v)) + 1;
        const signed_bitcount = plain_bitcount + 1;
        const bytecount = (signed_bitcount + 7) >> 3;
        if (bytecount <= 16) {
            this.emitbyte(Tag.MediumInteger_lo + bytecount - 1);
        } else {
            this.emitbyte(Tag.SignedInteger);
            this.varint(bytecount);
        }
        const enc = (n, x) => {
            if (n > 0) {
                enc(n - 1, x >> 8);
                this.emitbyte(x & 255);
            }
        };
        enc(bytecount, v);
    }

    encodebytes(tag: Tag, bs: Uint8Array) {
        this.emitbyte(tag);
        this.varint(bs.length);
        this.emitbytes(bs);
    }

    encodevalues(tag: Tag, items: Iterable<Value>) {
        this.emitbyte(tag);
        for (let i of items) { this.push(i); }
        this.emitbyte(Tag.End);
    }

    encoderawvalues(tag: Tag, items: BytesLike[]) {
        this.emitbyte(tag);
        items.forEach((i) => this.emitbytes(underlying(i)));
        this.emitbyte(Tag.End);
    }

    push(v: any) {
        if (typeof v === 'object' && v !== null && typeof v[PreserveOn] === 'function') {
            v[PreserveOn](this);
        }
        else if (typeof v === 'boolean') {
            this.emitbyte(v ? Tag.True : Tag.False);
        }
        else if (typeof v === 'number') {
            if (v >= -3 && v <= 12) {
                this.emitbyte(Tag.SmallInteger_lo + ((v + 16) & 0xf));
            } else {
                this.encodeint(v);
            }
        }
        else if (typeof v === 'string') {
            this.encodebytes(Tag.String, new Bytes(v)._view);
        }
        else if (typeof v === 'symbol') {
            const key = Symbol.keyFor(v);
            if (key === void 0) throw new EncodeError("Cannot preserve non-global Symbol", v);
            this.encodebytes(Tag.Symbol, new Bytes(key)._view);
        }
        else if (ArrayBuffer.isView(v)) {
            if (v instanceof Uint8Array) {
                this.encodebytes(Tag.ByteString, v);
            } else {
                const bs = new Uint8Array(v.buffer, v.byteOffset, v.byteLength);
                this.encodebytes(Tag.ByteString, bs);
            }
        }
        else if (Array.isArray(v)) {
            this.encodevalues(Tag.Sequence, v);
        }
        else if (typeof v === 'object' && v !== null && typeof v[Symbol.iterator] === 'function') {
            this.encodevalues(Tag.Sequence, v as Iterable<Value>);
        }
        else {
            throw new EncodeError("Cannot encode", v);
        }
        return this; // for chaining
    }
}

export function encode(v: any, options?: EncoderOptions): Bytes {
    return new Encoder(options).push(v).contents();
}

export function encodeWithAnnotations(v: any, options: EncoderOptions = {}): Bytes {
    return encode(v, { ... options, includeAnnotations: true });
}