import { WebServer } from "tgrid/protocols/web/WebServer";
import { WebConnector } from "tgrid/protocols/web/WebConnector";
import { Driver } from "tgrid/basic/Driver";

class Something
{
    public trace(...args: any[]): void
    {
        console.log(...args);
    }
}

async function main(): Promise<void>
{
    let server: WebServer = new WebServer();
    await server.open(10000, async acceptor =>
    {
        await acceptor.accept(new Something());
    });

    let connector: WebConnector = new WebConnector();
    await connector.connect("ws://127.0.0.1:10000");

    let something: Driver<Something> = connector.getDriver<Something>();
    await something.trace(1, { obj: {} }, undefined, "text");

    await connector.close();
    await server.close();
}
main();

console.log(JSON.stringify([1, 2, undefined, 'text']));

export namespace Invoke
{
    export interface IFunction
    {
        uid: number;
        listener: string;
        parameters: IParameter[];
    }
    export interface IParameter
    {
        type: string;
        value: any;
    }
}

import { WebConnector } from "tgrid/protocols/web/WebConnector";
import { Driver } from "tgrid/components/Driver";

async function main(): Promise<void>
{
    let connector: WebConnector;
    let driver: Driver<IController> = connector.getDriver();

    // not supported yet, but should be possible
    console.log(driver instanceof Driver); // true
}

export declare type Driver<Controller extends object, Parametric extends boolean = false> = Driver.Promisive<Controller, Parametric>;
export declare var Driver: {
    new (): {};
};
export declare namespace Driver {
    export type Promisive<Instance extends object, UseParametric extends boolean = false> = {
        readonly [P in keyof Instance]: Instance[P] extends Function ? Functional<Instance[P], UseParametric> : value_of<Instance[P]> extends object ? Instance[P] extends object ? Promisive<Instance[P], UseParametric> : never : never;
    } & IRemoteObject;
    export type Functional<Method extends Function, UseParametric extends boolean = false> = (Method extends (...args: infer Params) => infer Ret ? Ret extends Promise<infer PromiseRet> ? (...args: FunctionalParams<Params, UseParametric>) => Promise<Primitive<PromiseRet>> : (...args: FunctionalParams<Params, UseParametric>) => Promise<Primitive<Ret>> : (...args: any[]) => Promise<any>) & IRemoteFunction;
    type FunctionalParams<Params extends any[], UseParametric extends boolean> = UseParametric extends true ? Parametric<Params> : Params;
    export type Primitive<Instance> = value_of<Instance> extends object ? Instance extends object ? Instance extends IJsonable<infer Raw> ? value_of<Raw> extends object ? Raw extends object ? PrimitiveObject<Raw> : never : value_of<Raw> : PrimitiveObject<Instance> : never : value_of<Instance>;
    type PrimitiveObject<Instance extends object> = {
        [P in keyof Instance]: Instance[P] extends Function ? never : Primitive<Instance[P]>;
    };
    export type Parametric<Arguments extends any[]> = {
        [P in keyof Arguments]: ParametricValue<Arguments[P]>;
    };
    type ParametricValue<Instance> = value_of<Instance> | Primitive<Instance> | IJsonable<Primitive<Instance>>;
    type value_of<Instance> = is_value_of<Instance, Boolean> extends true ? boolean : is_value_of<Instance, Number> extends true ? number : is_value_of<Instance, String> extends true ? string : Instance;
    type is_value_of<Instance, Object extends IValueOf<any>> = Instance extends Object ? Object extends IValueOf<infer Primitive> ? Instance extends Primitive ? false : true : false : false;
    interface IRemoteObject {
        constructor: never;
        prototype: never;
    }
    type IRemoteFunction = {
        [P in keyof Function | "Symbol"]: never;
    };
    interface IValueOf<T> {
        valueOf(): T;
    }
    export {};
}

/* ----------------------------------------------------------------
    ORIGINAL TYPES
---------------------------------------------------------------- */
declare class Feature
{
    public count(): Number;
    public getReport(): Report;
    public getMembers(): Member[];

    public insertMember(obj: Member): void;
    public findMember(key: number | string): Member | null;

    public publish(x: Member, y: Report, pred: Number): Report;
}

declare class Report implements IReport
{
    public code: string;
    public title: string;
    public content: string;

    public archive(): void;
    public publish(): void;
}

declare class Member implements IJsonable<IMember>
{
    private id_: number;
    private name_: string;

    public login(password: string): void;
    public update(name: string): void;
    public toJSON(): IMember
}

/* ----------------------------------------------------------------
    PRIMITIVE TYPES
---------------------------------------------------------------- */
type Driver<Feature> = 
{
    public count(): Promise<number>;
    public getReport(): Promise<IReport>;
    public getMembers(): Promise<IMember[]>;

    public insertMember(obj: Member | IMember | IJsonable<IMember>): Promise<void>;
    public findMember(key: number | string): Promise<Member | null>;

    public publish
        (
            x: Member | IMember | IJsonable<IMember>, 
            y: Report | IReport | IJsonable<IReport>, 
            pred: number
        ): Promise<IReport>;
};

interface IReport
{
    code: string;
    title: string;
    content: string;
}

interface IMember
{
    id: number;
    name: string;
}

export class WebConnector
{
    // NOT EXTENTABLE
    public async connection(url: string, timeout?: number): Promise<void>;

    // EXTENDABLE
    public async connect(url: string, options: WebConnector.IConnectOptions): Promise<void>;
}
export namespace WebConnector
{
    export interface IConnectOptions
    {
        timeout: number
    }
}

export class WebConnector<
        Header extends object | null, 
        Provider extends object | null>
{
    public constructor(header: Header, provider: Provider);
}

export class WorkerConnector<Provider extends object>
{
    public compile(content: string, ...args: string[]): Promise<void>;
    public connect(jsFile: string, ...args: string[]): Promise<void>;
}

export class WorkerConnector<Provider extends object>
{
    public compile<Headers extends object>(content: string, headers: Headers): Promise<void>;
    public connect<Headers extends object>(jsFile: string, headers: Headers): Promise<void>;
}

export class WorkerConnector<Header, Provider extends object | null>
    extends ConnectorBase<Header, Provider>
    implements IWorkerSystem
{
    /**
     * Initializer Constructor.
     * 
     * @param header An object containing initialization data like activation.
     * @param provider An object providing features for remote system.
     * @param type You can specify the worker mode when NodeJS. Default is "thread".
     */
    public constructor
        (
            header: Header, 
            provider: Provider, 
            type: "thread" | "process" = "thread"
        )
}

namespace tgrid.protocols.web
{
    export class WebServer
    {
        /* ----------------------------------------------------------------
            CONSTRUCTORS
        ---------------------------------------------------------------- */
        /**
         * Default Constructor for the `ws` server.
         * 
         * Create an websocket server (`ws://`).
         */
        public constructor();

        /**
         * Initializer Constructor for the `wss` server.
         * 
         * Create a secured websocket server (`wss://`).
         * 
         * @param key Key string.
         * @param cert Certification string.
         */
        public constructor(key: string, cert: string);

        /* ----------------------------------------------------------------
            OPERATIONS
        ---------------------------------------------------------------- */
        /**
         * Open server.
         * 
         * @param port Port number to listen.
         * @param cb Callback function whenever client connects.
         */
        public open<Ret>(port: number, cb: (acceptor: WebAcceptor) => Ret): Promise<void>;

        /**
         * Close server.
         */
        public close(): Promise<void>;

        /**
         * Current state.
         */
        public get state(): WebServer.State;
    }

    export namespace WebServer
    {
        export const enum State 
        { 
            NONE = -1, 
            OPENING, 
            OPEN, 
            CLOSING, 
            CLOSED 
        }
    }
}

namespace tgrid.protocols.web
{
    export class WebAcceptor 
        extends basic.CommunicatorBase
    {
        /* ----------------------------------------------------------------
            CONSTRUCTORS
        ---------------------------------------------------------------- */
        /**
         * Hidden Constructor.
         * 
         * You can't create WebAcceptor by yourself. It would be created only by the WebServer.
         */
        private constructor(request);

        /**
         * Close connection.
         */
        public close(): Promise<void>;

        /* ----------------------------------------------------------------
            HANDSHAKES
        ---------------------------------------------------------------- */
        /**
         * Accept connection.
         * 
         * @param protocol Protocol you want to specialize.
         * @param allowOrigin If you want to restrict connection origin, then specialize it.
         * @param cookies Cookies to make client storing it.
         */
        public accept(protocol?: string, allowOrigin?: string, cookies?: ICookie[]): Promise<void>;

        /**
         * Reject connection.
         * 
         * @param status Status code.
         * @param reason Detailed reason to reject.
         * @param extraHeaders Extra heaaders if required.
         */
        public reject(status?: number, reason?: string, extraHeaders?: object): Promise<void>;

        /**
         * Start listening.
         * 
         * Start listening data (function requests) from the remote client.
         * 
         * @param provider An object to provide functions for the remote client.
         */
        public listen<Provider extends object>
            (provider: Provider): Promise<void>;

        /* ----------------------------------------------------------------
            ACCESSORS
        ---------------------------------------------------------------- */
        /**
         * Get driver for remote controller.
         *
         * @return A driver for the remote Controller.
         */
        public getDriver<Controller extends object>(): Driver<Controller>;

        /**
         * Join connection.
         */
        public join(): Promise<void>;

        //----
        // PROPERTIES
        //----
        public get state(): State;
        public get secured(): boolean;

        public get path(): string;
        public get protocol(): string;
        public get extensions(): string;
    }

    export namespace WebAcceptor
    {
        export interface ICookie { ... };

        export const enum State { ... }
    }
}

namespace tgrid.protocols.web
{
    export class WebConnector<Provider extends object>
        extends basic.CommunicatorBase<Provider>
    {
        /* ----------------------------------------------------------------
            CONSTRUCTORS
        ---------------------------------------------------------------- */
        /**
         * Initializer Constructor.
         * 
         * @param provider A provider for server.
         */
        public constructor(provier?: Provider);

        /**
         * Connect to remote web socket server.
         *
         * @param url URL address to connect.
         * @param protocols Candidate protocols to specialize.
         */
        public connect(url: string, protocols?: string | string[]): Promise<void>;

        /**
         * Close connection.
         * 
         * @param code Closing code.
         * @param reason Reason why.
         */
        public close(code?: number, reason?: string): Promise<void>;

        /* ----------------------------------------------------------------
            ACCCSSORS
        ---------------------------------------------------------------- */
        /**
         * Get driver for remote controller.
         *
         * @return A driver for the remote Controller.
         */
        public getDriver<Controller extends object>(): Driver<Controller>;

        /**
         * Wait server to provide.
         * 
         * Wait server to specify its `Provider`.
         */
        public wait(): Promise<void>;

        /**
         * Join connection.
         */
        public join(): Promise<void>;

        //----
        // PROPERTIES
        //----
        public get state(): WebConnector.State;
        public get url(): string;
        public get protocol(): string;
        public get extensions(): string;
    }

    export namespace WebConnector
    {
        export const enum State
        {
            NONE = -1,
            CONNECTING,
            OPEN,
            CLOSING,
            CLOSED
        }
    }
}

import * as std from "tstl";
import * as tgrid from "tgrid";

import { Calculator } from ".internal/Calculator";

async function main(): Promise<void>
{
    let server: WebServer = new WebServer();
    await server.open(PORT, async acceptor =>
    {
        await acceptor.accept(); // ALLOW CONNECTION
        await acceptor.listen(/calculator/.test(acceptor.path)
            ? new Calculator()
            : new std.Vector<number>()); // SET LISTENER
    });
}

import { Vector } from "tstl/container";
import { WebConnector } from "tgrid/protocols/web";
import { Driver } from "tgrid/basic";

type IVector<T> = Pick<Vector<T>, "size" | "at" | "push_back">;

async function main(): Promise<void>
{
    let connector: WebConnector = new WebConnector();
    await connector.connect("ws://127.0.0.1:10100");

    let vec: Driver<IVector<number>> = connector.getDriver<IVector<number>>();
    for (let i: number = 0; i < 5; ++i)
        await vec.push_back(i);

    console.log("size:", await vec.size());
    for (let i: number = 0; i < await vec.size(); ++i)
        console.log("  element:", await vec.at(i));
}
main();

import { WebConnector } from "tgrid/protocols/web";
import { Driver } from "tgrid/basic";
import { ICalculator } from "./internal/Calculator";

async function main(): Promise<void>
{
    //----
    // PREPARES
    //----
    // DO CONNECT
    let connector: WebConnector = new WebConnector();
    await connector.connect("ws://127.0.0.1:10102");

    // GET DRIVER
    let calc: Driver<ICalculator> = connector.getDriver<ICalculator>();
    
    //----
    // CALL FUNCTIONS
    //----
    // FUNCTIONS IN THE ROOT SCOPE
    console.log("1 + 6 =", await calc.plus(1, 6));
    console.log("7 * 2 =", await calc.multiplies(7, 2));

    // FUNCTIONS IN AN OBJECT (SCIENTIFIC)
    console.log("3 ^ 4 =", await calc.scientific.pow(3, 4));
    console.log("log (2, 32) =", await calc.scientific.log(2, 32));

    try
    {
        // TO CATCH EXCEPTION IS STILL POSSIBLE
        await calc.scientific.sqrt(-4);
    }
    catch (err)
    {
        console.log("SQRT (-4) -> Error:", err.message);
    }

    // FUNCTIONS IN AN OBJECT (STATISTICS)
    console.log("Mean (1, 2, 3, 4) =", await calc.statistics.mean(1, 2, 3, 4));
    console.log("Stdev. (1, 2, 3, 4) =", await calc.statistics.stdev(1, 2, 3, 4));

    //----
    // TERMINATE
    //----
    await connector.close();
}
main();

/* ----------------------------------------------------------------
    INTERFACES
---------------------------------------------------------------- */
export interface ICalculator
{
    scientific: IScientific;
    statistics: IStatistics;

    plus(x: number, y: number): number;
    minus(x: number, y: number): number;
    multiplies(x: number, y: number): number;
    divides(x: number, y: number): number;
}

export interface IScientific
{
    pow(x: number, y: number): number;
    sqrt(x: number): number;
    log(x: number, y: number): number;
}

export interface IStatistics
{
    mean(...elems: number[]): number;
    stdev(...elems: number[]): number;
}

/* ----------------------------------------------------------------
    CLASSES
---------------------------------------------------------------- */
export class Calculator implements ICalculator
{
    public scientific = new Scientific();
    public statistics = new Statistics();

    public plus(x: number, y: number): number
    {
        return x + y;
    }
    public minus(x: number, y: number): number
    {
        return x - y;
    }
    
    public multiplies(x: number, y: number): number
    {
        return x * y;
    }
    public divides(x: number, y: number): number
    {
        if (y === 0)
            throw new Error("Divided by zero.");
        return x / y;
    }
}

class Scientific implements IScientific
{
    public pow(x: number, y: number): number
    {
        return Math.pow(x, y);
    }

    public log(x: number, y: number): number
    {
        if (x < 0 || y < 0)
            throw new Error("Negative value on log.");
        return Math.log(y) / Math.log(x);
    }

    public sqrt(x: number): number
    {
        if (x < 0)
            throw new Error("Negative value on sqaure.");
        return Math.sqrt(x);
    }
}

class Statistics implements IStatistics
{
    public mean(...elems: number[]): number
    {
        let ret: number = 0;
        for (let val of elems)
            ret += val;
        return ret / elems.length;
    }

    public stdev(...elems: number[]): number
    {
        let mean: number = this.mean(...elems);
        let ret: number = 0;

        for (let val of elems)
            ret += Math.pow(val - mean, 2);

        return Math.sqrt(ret / elems.length);
    }
}

const PORT = 10101;

export async function test_web_server_close(): Promise<void>
{
    let server: WebServer<null, null> = new WebServer();
    await server.open(PORT, acceptor => acceptor.accept(null));

    let connector: WebConnector<null, null> = new WebConnector(null, null);
    await connector.connect(`ws://127.0.0.1:${PORT}`);

    server.close().then(() =>
    {
        // it would be shown after 5,000 milliseconds later
        console.log("WOW");
    });
    await sleep_for(5000);
    await connector.close();
}

namespace tgrid.components
{
    // Message would be one of them.
    export type Invoke = IFunction | IReturn;

    export interface IFunction
    {
        uid: number; // identifier
        listener: string; // function (sometimes capsuled in objects) to call
        parameters: IParameter[]; // parameters for the function
    }
    export interface IParameter
    {
        type: string;
        value: any;
    }

    export interface IReturn
    {
        uid: number; // identifier
        success: boolean; // true -> return, false -> exception
        value: any | undefined; // returned value or thrown exception
    }
}

namespace tgrid.components
{
    export abstract class Communicator<Provider extends object>
    {
        /* ----------------------------------------------------------------
            CONSTRUCTORS
        ---------------------------------------------------------------- */
        /**
         * Initializer Constructor.
         * 
         * @param provider An object providing functions for the remote system.
         */
        protected constructor(provider?: Provider);

        /**
         * Destruct the communicator.
         * 
         * A destructor function should be called when the network communication has closed. 
         * It would destroy all RFC (function calls to the remote system, via the 
         * `Driver<Controller>`).
         * 
         * @param error An error instance to be thrown to the all remote functions that are 
         *              not returned yet.
         */
        protected destructor(error?: Error): Promise<void>;

        /* ----------------------------------------------------------------
            ACCESSORS
        ---------------------------------------------------------------- */
        /**
         * Get driver for remote controller.
         * 
         * The `Controller` is an interface who defines provided functions from the remote 
         system. The `Driver` is an object who makes to call remote functions, defined in the 
         * `Controller` and provided by `Provider` in the remote system, possible.
         * 
         * @return A driver for the remote controller.
         */
        public getDriver<Controller extends object>(): Driver<Controller>;

        /**
         * Join connection.
         * 
         * Wait until the connection to be closed (until `CommunicatorBase.desturctor()` called).
         */
        public join(): Promise<void>;

        /* ----------------------------------------------------------------
            COMMUNICATORS
        ---------------------------------------------------------------- */
        /**
         * Data Replier.
         * 
         * A function should be called when data has come from the remote system. 
         * 
         * When you receive a message from the remote system, then parse the message with your
         * special protocol and convert it to be an *Invoke* object. After that conversion, call 
         * this method.
         * 
         * @param invoke Structured data converted by your special protocol.
         */
        protected replyData(invoke: Invoke): void;

        /** 
         * A function sending data to the remote system.
         */
        protected abstract sendData(invoke: Invoke): void;

        /**
         * A predicator inspects whether the *network communication* is ready.
         */
        protected abstract inspectReady(): Error | null;
    }
}

import { WebConnector } from "tgrid/protocols/web/WebConnector";
import { Driver } from "tgrid/components/Driver";

interface ICalculator
{
    // Possible to access
    plus(x: number, y: number): number;
    minus(x: number, y: number): number;
    statistics: IStatistics;

    // Impossible to access
    _Divides(x: number, y: number): number; // impossible
    scientific_: IScientific; // impossible
}

async main(): Promise<void>
{
    //----
    // PREPARATION
    //----
    let connector: WebConnector = new WebConnector();
    await connector.connect("ws://127.0.0.1:8091");

    let calc: Driver<ICalculator> = connector.getDriver();

    //----
    // REMOTE FUNCTION CALLS
    //----
    // POSSIBLE
    await calc.plus(5, 6);
    await calc.minus(7, 2);
    await calc.statistics.mean(1, 2, 3, 4);

    // IMPOSSIBLE - be RuntimeError, Also should be compile error
    await calc._Divides(72, 9);
    await calc.scientific_.pow(3, 4);

    await connector.close();
}
main();

export abstract class ConnectorBase<Header, Provider extends object | null>
    extends Communicator<Provider>
{
    public constructor(header: Header, provider: Provider);
    public get header(): Header;
    public get state(): ConnectorBase.State;

    protected inspectReady(method: string): Error | null;
}

export abstract class AcceptorBase<Header, Provider extends object | null>
    extends Communicator<Provider>
{
    protected constructor(header: Header);
    public get header(): Header;
    public get state(): AcceptorBase.State;

    protected inspectReady(method: string): Error | null;
}

import { WorkerConnector } from "tgrid/protocols/workers/WorkerConnector";

async function main(): Promise<void>
{
    let connector: WorkerConnector();
    await connector.connect(__dirname + "/server.js");

    await connector.join();
}
main();

import { WorkerServer } from "tgrid/protocols/workers/WorkerServer";

async function main(): Promise<void>
{
    let server: WorkerServer = new WorkerServer();
    await server.open();
    await server.join();

    console.log("Cannot reach to this code");
    console.log("The program would be terminated before");
}
main();

namespace tgrid.protocols.workers
{
    export class WorkerServer<Provider extends object>
        extends basic.CommunicatorBase<Provider>
    {
        /* ----------------------------------------------------------------
            CONSTRUCTORS
        ---------------------------------------------------------------- */
        /**
         * Initializer Constructor.
         * 
         * @param provider An object providing functions for the connector.
         */
        public constructor(provider: Provider);

        /**
         * Close connection.
         */
        public close(): Promise<void>;

        /* ----------------------------------------------------------------
            ACCESSORS
        ---------------------------------------------------------------- */
        /**
         * Get driver for remote controller.
         *
         * @return A driver for the remote Controller.
         */
        public getDriver<Controller extends object>(): components.Driver<Controller>;

        /**
         * Join connection.
         */
        public join(): Promise<void>;
    }
}

namespace tgrid.protocols.workers
{
    export class WorkerConnector<Provider extends object>
        extends basic.CommunicatorBase<Provider>
    {
        /* ----------------------------------------------------------------
            CONSTRUCTORS
        ---------------------------------------------------------------- */
        /**
         * Initializer Constructor.
         * 
         * @param provider An object providing functions for the server.
         */
        public constructor(provider: Provider);
        
        /**
         * Connect to worker server with compilation.
         * 
         * @param source JS Source Code to be server with compilation. 
         *               It would better make the source code to be bundled.
         */
        public compile(source: string): Promise<void>;

        /**
         * Connect to worker server.
         * 
         * @param jsFile JS File to be worker server.
         */
        public connect(jsFile: string): Promise<void>;

        /**
         * Close connection.
         */
        public close(): Promise<void>;

        /* ----------------------------------------------------------------
            ACCESSORS
        ---------------------------------------------------------------- */
        /**
         * Get driver for remote controller.
         *
         * @return A driver for the remote Controller.
         */
        public getDriver<Controller extends object>(): components.Driver<Controller>;

        /**
         * Join connection.
         */
        public join(): Promise<void>;
    }
}

namespace tgrid.protocols.workers
{
    export class SharedWorkerServer
    {
        /**
         * Default Constructor.
         */
        public constructor();

        /**
         * Open Server.
         * 
         * @param cb Callback function called whenever client connects.
         */
        public open(cb: (acceptor: SharedWorkerAcceptor) => any): Promise<void>;

        /**
         * Close Server.
         */
        public close(): Promise<void>;
    }
}

namespace tgrid.protocols.workers
{
    export class SharedWorkerAcceptor
        extends basic.CommunicatorBase
    {
        /* ----------------------------------------------------------------
            CONSTRUCTORS
        ---------------------------------------------------------------- */
        /**
         * Hidden Constructor.
         * 
         * You can't create WebAcceptor by yourself. It would be created only by the WebServer.
         */
        private constructor(server, port);

        /**
         * Close connection.
         */
        public close(): Promise<void>;

        /* ----------------------------------------------------------------
            HANDSHAKES
        ---------------------------------------------------------------- */
        /**
         * Accept connection.
         */
        public accept(): Promise<void>;

        /**
         * Reject connection.
         */
        public reject(): Promise<void>;

        /**
         * Start listening.
         * 
         * Start listening data (function requests) from the remote client.
         * 
         * @param provider An object to provide functions for the remote client.
         */
        public listen<Provider extends object>
            (provider: Provider): Promise<void>;

        /* ----------------------------------------------------------------
            ACCCSSORS
        ---------------------------------------------------------------- */
        /**
         * Get driver for remote controller.
         *
         * @return A driver for the remote Controller.
         */
        public getDriver<Controller extends object>(): components.Driver<Controller>;

        /**
         * Wait server to provide.
         * 
         * Wait server to specify its `Provider`.
         */
        public wait(): Promise<void>;

        /**
         * Join connection.
         */
        public join(): Promise<void>;
    }
}

namespace tgrid.protocols.workers
{
    export class SharedWorkerConnector<Provider extends object>
        extends basic.CommunicatorBase<Provider>
    {
        /**
         * Initializer Constructor.
         * 
         * @param provider A provider for server.
         */
        public constructor(provider: Provider);
        
        /**
         * Connect to shared worker server.
         * 
         * @param jsFile JS File to be worker server.
         */
        public connect(jsFile: string): Promise<void>;

        /**
         * Close connection.
         */
        public close(): Promise<void>;

        /* ----------------------------------------------------------------
            ACCCSSORS
        ---------------------------------------------------------------- */
        /**
         * Get driver for remote controller.
         *
         * @return A driver for the remote Controller.
         */
        public getDriver<Controller extends object>(): components.Driver<Controller>;

        /**
         * Wait server to provide.
         * 
         * Wait server to specify its `Provider`.
         */
        public wait(): Promise<void>;

        /**
         * Join connection.
         */
        public join(): Promise<void>;

        public get state(): SharedWorkerConnector.State;
    }

    export namespace SharedWorkerConnector
    {
        export const enum State { ... }

        /**
         * Compile source to JS File.
         * 
         * @return Path of compiled JS File.
         */
        export function compile(source: string): string;
    }
}

import { WorkerServer } from "tgrid/protocols/workers";
import { Driver } from "tgrid/basic";

import { Mutex } from "tstl/thread";
import { randint } from "tstl/algorithm";

interface IController
{
    mutex: Mutex;
    print(str: string): void;
}

async function main(str: string): Promise<void>
{
    // PREPARE SERVER & DRIVER
    let server: WorkerServer = new WorkerServer();
    let driver: Driver<IController> = server.getDriver<IController>();

    // REMOTE FUNCTION CALLS
    await driver.mutex.lock();
    {
        for (let i: number = 0; i < 20; ++i)
            await driver.print(str);
        await driver.print("\n");
    }
    await driver.mutex.unlock();

    // CLOSE THE SERVER (WORKER)
    await server.close();
}
main(randint(0, 9) + "");

import { WorkerConnector } from "tgrid/protocols/workers";

import { Vector } from "tstl/container";
import { Mutex } from "tstl/thread";

// FEATURES TO PROVIDE
namespace provider
{
    export var mutex = new Mutex();
    export function print(str: string): void
    {
        process.stdout.write(str);
    }
}

async function main(): Promise<void>
{
    let workers: Vector<WorkerConnector<typeof provider>> = new Vector();

    // CREATE WORKERS
    for (let i: number = 0; i < 4; ++i)
    {
        workers.push_back(new WorkerConnector(provider));
        workers.back().connect(__dirname + "/server.js");
    }

    // WAIT THEM TO BE CLOSED
    for (let w of workers)
        await w.join();
}
main();

export class WebConnector<Provider extends object>
{
    public connect<Headers extends object>(url: string, headers?: Headers): Promise<void>;
}

export class WebAcceptor<Headers extends object, Provider extends object>
{
    public get path(): string;
    public get state(): string;
    public get headers(): Headers;
}

export class WebServer<Provider extends object>
{
    public open<Headers extends object>
    (
        port: number, 
        handler: (acceptor: WebAcceptor<Headers, Provider>) => any
    ): Promise<void>;
}

/* ----------------------------------------------------------------
    ORIGINAL TYPES
---------------------------------------------------------------- */
class Feature
{
    public getReport(): Report;
    public getMembers(): Member[];

    public insertMember(id: number, name: string): Member;
    public findMember(key: number | string): Member | null;
}

class Report implements IReport
{
    public code: string;
    public title: string;
    public content: string;

    public archive(): void;
    public publish(): void;
}

class Member implements IJsonable<IMember>
{
    private id_: number;
    private name_: string;

    public login(password: string): void;
    public update(name: string): void;
    public toJSON(): IMember
}

/* ----------------------------------------------------------------
    PRIMITIVE TYPES
---------------------------------------------------------------- */
type Driver<Feature> = 
{
    getReport(): Promise<IReport>;
    getMembers(): Promise<IMember[]>;

    insertMember(id: number, name: string): Promise<IMember>;
    findMember(key: number | string): Promise<IMember | null>;
}

interface IReport
{
    code: string;
    title: string;
    content: string;
}

interface IMember
{
    id: number;
    name: string;
}

type MyBoolean = Driver.Pritimive<false>; // be boolean
type MyNumber = Driver.Pritimive<4>; // be number
type MyString = Driver.Pritimive<"my_literal">; // be string

{
    "compilerOptions: {
        ....,
        "strict": true
    }
}

import { WebConnector } from "tgrid/protocols/web/WebConnector";
import { Driver } from "tgrid/components/Driver";

interface ICalculator
{
    scientific: IScientific;
    statistics: IStatistics;

    plus(x: number, y: number): number;
    minus(x: number, y: number): number;
    multiplies(x: number, y: number): number;
    divides(x: number, y: number): number;
}

async function main(): Promise<void>
{
    let connector: WebConnector = new WebConnector();
    await connector.connect("ws://127.0.0.1:10101");

    let calc: Driver<ICalculator> = connector.getDriver();

    // CAN SEE IMPLEMENTATION CODE OF REMOTE PROVIDER
    console.log(await calc.constructor.toString()); 
    console.log(await calc.plus.toString());

    // DANGEROUS ACCESSMENTS, SHOULD BE BLOCKED
    console.log(await calc.prototype.multiplies.bind({})(3, 4));
    console.log(await calc.prototype.divides.call({}, 3, 4));

    await connector.close();
}

type Driver<ICalculator> = 
{
    scientific: Driver<IScientific>;
    statistics: Driver<IStatistics>;

    // FUNCTIONS ARE ENHANCED BY FUNCTOR
    plus: Functor<(x: number, y: number) => Promise<number>>;
    minus: Functor<(x: number, y: number) => Promise<number>>;
    multiplies: Functor<(x: number, y: number) => Promise<number>>;
    divides: Functor<(x: number, y: number) => Promise<number>>;

    // CANNOT ACCESS TO DANGEROUS MEMBERS
    constructor: never;
    prototype: never;
};

type Functor<T extends Function> = T & 
{
    constructor: never;
    prototype: never;
    Symbol: never;
    bind: never;
    ...
};

import tgrid from "tgrid";

import components from "tgrid/components";
import protocols from "tgrid/protocols";
import web from "tgrid/protocols/web";
import workers from "tgrid/protocols/workers";
import utils from "tgrid/utils";

namespace tgrid.components
{
    export class Driver<Controller extends object>
        extends Proxy<Promisify<Controller>>
    {
        public constructor(communicator: CommunicatorBase);
    }

    // Functions must be converted to return Promise<T> value.
    // sum(x: number, y: number): number -->> sum(x: number, y: number): Promise<number>
    type Promisify<Controller extends object>;
}

// Can be a "Controller"
interface ICalculator
{
    plus(x: number, y: number): number;
    minus(x: number, y: number): number;
    multiplies(x: number, y: number): number;
    divides(x: number, y: number): number;
}

// Return type T must be converted to the Promise<T>
type Promisify<ICalculator> = 
{
    plus(x: number, y: number): Promise<number>;
    minus(x: number, y: number): Promise<number>;
    multiplies(x: number, y: number): Promise<number>;
    divides(x: number, y: number): Promise<number>;
};