import * as types from ".";
import * as web3 from "@solana/web3.js";
import * as wh from "@certusone/wormhole-sdk";
import { BigNumber, ethers } from "ethers";

/// patching generated types ~~~~~~~~ Scary

declare module "./generated_client/types" {
    export interface XTokenLocator {
        toNative(): string;
        toEvmFormat(): {
            chainId: number;
            tokenAddr: Buffer;
        };
    }
    export interface ForeignAddr {
        toHex(): string;
        toBytes(): Uint8Array;
        toNative(chainId: number | wh.ChainId): string;
    }
}

export class XTokenLocatorExt {
    static toNative(x: types.XTokenLocator): string {
        return ForeignAddrExt.toNative(x.address, x.chainId);
    }
    static fromNative(s: string, chainId: wh.ChainId): types.XTokenLocator {
        return new types.XTokenLocator({
            address: ForeignAddrExt.fromNative(s, chainId),
            chainId,
        });
    }
}

export class ForeignAddrExt {
    static fromPubkey(k: web3.PublicKey): types.ForeignAddr {
        return pubkeyToForeignAddr(k);
    }
    static fromNative(s: string, chainId: wh.ChainId): types.ForeignAddr {
        return ForeignAddrExt.fromBytes(wh.tryNativeToUint8Array(s, chainId));
    }
    static fromBytes(bytes: Uint8Array): types.ForeignAddr {
        return new types.ForeignAddr({
            inner: Array.from(bytes),
        });
    }
    static fromHex(s: string): types.ForeignAddr {
        const buf = wh.hexToUint8Array(s);
        return new types.ForeignAddr({
            inner: Array(32 - buf.length)
                .fill(0)
                .concat(Array.from(buf)),
        });
    }
    static toBytes(x: types.ForeignAddr): Uint8Array {
        return new Uint8Array(x.inner);
    }
    static toHex(x: types.ForeignAddr): string {
        return wh.uint8ArrayToHex(ForeignAddrExt.toBytes(x));
    }
    static toNative(
        x: types.ForeignAddr,
        chainId: number | wh.ChainId,
    ): string {
        return wh.tryUint8ArrayToNative(
            ForeignAddrExt.toBytes(x),
            <wh.ChainId>chainId,
        );
    }
}

// types.ForeignAddr.prototype.fromHex = function (s: string): types.ForeignAddr {
//   const buf = wh.hexToUint8Array(s);
//   return new types.ForeignAddr({ inner: Array.from(buf) });
// };
types.ForeignAddr.prototype.toBytes = function (): Uint8Array {
    return new Uint8Array(this.inner);
};
types.ForeignAddr.prototype.toHex = function toHex(): string {
    return wh.uint8ArrayToHex(this.toBytes());
};
types.ForeignAddr.prototype.toNative = function (
    chainId: number | wh.ChainId,
): string {
    return wh.tryUint8ArrayToNative(this.toBytes(), <wh.ChainId>chainId);
};

types.XTokenLocator.prototype.toNative = function () {
    return this.address.toNative(this.chainId);
};
types.XTokenLocator.prototype.toEvmFormat = function (): {
    chainId: number;
    tokenAddr: Buffer;
} {
    return xTokenLocatorGeneratedToEvm(this);
};

export function pubkeyToForeignAddr(pubkey: web3.PublicKey): types.ForeignAddr {
    return new types.ForeignAddr({ inner: Array.from(pubkey.toBytes()) });
}

export function evmAddrToXTokenLocator(
    chainId: number,
    addr: string,
): { chainId: number; tokenAddr: Buffer } {
    return { chainId, tokenAddr: evmAddrToBytes(addr) };
}

export function xTokenLocatorGeneratedToEvm(input: types.XTokenLocator): {
    chainId: number;
    tokenAddr: Buffer;
} {
    return {
        chainId: input.chainId,
        tokenAddr: Buffer.from(input.address.inner),
    };
}

export function evmAddrToBytes(evmAddr: string): Buffer {
    const smallBuf = ethers.utils.arrayify(evmAddr);
    const buf = Buffer.alloc(32);
    Buffer.from(smallBuf).copy(buf, buf.length - smallBuf.length);
    return buf;
}

export class XTokenAmount {
    constructor(
        public readonly token: types.XTokenLocator,
        public readonly rawAmt: BigNumber,
    ) {}
}