eff.ts

import readline  from "readline";


interface Effect<TResult> {
    type: string
}

interface Log extends Effect<void> {
    type: "log"
    msg: string
}

interface Rand extends Effect<number> {
    type: "rand"
    min: number
    max: number
}

interface Prompt extends Effect<string> {
    type: "prompt"
    msg: string
}


interface PromiseEffect extends Effect<unknown> {
    type: "promise"
    promise: Promise<unknown>
}

type Eff<TResult, TEffect extends Effect<TResult>> = Generator<TEffect, TResult, any>

function* effect<TResult, TEffect extends Effect<TResult>>(effect: TEffect): Eff<TResult, TEffect> {
    return yield effect;
}

function log(msg: string): Eff<void, Log> {
    return effect({ type: "log", msg: msg });
}

function rand(min: number, max: number): Eff<number, Rand>  {
    return effect({ type: "rand", min: min, max: max });
}

function prompt(msg: string): Eff<string, Prompt> {
    return effect({ type: "prompt", msg: msg });
}

function* guessGame(): Eff<void, Log | Rand | Prompt> {
    const secret = yield* rand(1, 100);
    for(let i = 1; i <= 10; i++) {
        const userInput = yield* prompt("Guess a number (1-100): ");
        const guess = parseInt(userInput);
        if (guess === secret) {
            yield* log("Congrats!!!");
            return;
        }
        else if (secret > guess) 
            yield* log("Secret is bigger!");
        else
            yield* log("Secret is smaller!");
    }
    yield* log(`GAME OVER - secret was ${secret}`);
}

function run(iter: Eff<void, Log | Rand | Prompt>) {
    const internalLogs: unknown[] = [];
    return new Promise((resolve, reject) => {
        const result = iter.next();
        function loop(result: IteratorResult<Log | Rand | Prompt, void>) {
            internalLogs.push(result.value);
            if (result.done)
                resolve({ result: result.value, logs: internalLogs });
            else {
                const effect = result.value;
                if (effect.type === "log") {
                    console.log(effect.msg);
                    loop(iter.next());
                }
                else if (effect.type === "rand") {
                    const randValue = Math.floor(Math.random() * effect.max) + effect.min;
                    loop(iter.next(randValue));
                }
                else if (effect.type === "prompt") {
                    const input = readline.createInterface({
                        input: process.stdin,
                        output: process.stdout,
                    });
                      
                    input.question(effect.msg,  (value) => {
                        input.close();
                        loop(iter.next(value));
                    });
                }
            }
        }
        loop(result);
    }); 

}

//const iter = guessGame();
//run(iter).then(x => console.log(x));



function* randHandler<TResult, TEffect extends Effect<TResult>>(iter: Eff<void, Rand | TEffect>): Eff<void, TEffect> {
    let result = iter.next();
    while (!result.done) {
        const effect = result.value;
        if (effect.type === "rand") {
            const randEffect = effect as Rand;
            const randValue = Math.floor(Math.random() * randEffect.max) + randEffect.min;
            result = iter.next(randValue);
        }
        else {
            const value = yield effect as TEffect;
            result = iter.next(value);
        }
    }
}

function* logHandler<TResult, TEffect extends Effect<TResult>>(iter: Eff<void, Log | TEffect>): Eff<void, TEffect> {
    let result = iter.next();
    while (!result.done) {
        const effect = result.value;
        if (effect.type === "log") {
            const logEffect = effect as Log;
            console.log(logEffect.msg);
            result = iter.next();
        }
        else {
            const value = yield effect as TEffect;
            result = iter.next(value);
        }
    }
}

function* promptHandler<TResult, TEffect extends Effect<TResult>>(iter: Eff<void, Prompt | TEffect>): Eff<void, PromiseEffect | TEffect> {

    let result = iter.next();
    while (!result.done) {
        const effect = result.value;
        if (effect.type === "prompt") {
            const promptEffect = effect as Prompt;
            function prompt(msg: string): Promise<string> {
                return new Promise((resolve, reject) => {
                    const input = readline.createInterface({
                        input: process.stdin,
                        output: process.stdout,
                    });
                        
                    input.question(msg,  (value) => {
                        input.close();         
                        resolve(value);
                    });
                });
            }
            const promise = prompt(promptEffect.msg);
            const value = yield { type: "promise", promise: promise } as PromiseEffect;
            result = iter.next(value);
        }
        else {
            const value = yield effect as TEffect;
            result = iter.next(value);
        }
    }
}

async function runHandler(iter: Eff<void, PromiseEffect>): Promise<void> {
    let result = iter.next();
    while (!result.done) {
        const effect = result.value;
        if (effect.type === "promise") {
            const value = await effect.promise;
            result = iter.next(value);
        }
        else
            throw new Error(`invalid effect ${effect.type}`);
    }
}


runHandler(logHandler(randHandler(promptHandler(guessGame()))));