index.js

'use strict';

export {
    FORM,
    INFORMATION,

    Message,
    lottus,
    redirect,
    blueprint,

    options_processor,
    input_processor,
    form_processor,

    format_message,

    InMemorySessionManager,

    process_w_session
}


/**
 * 
 * @param {object} options 
 * @returns {__lottus}
 */
function lottus(options){
    if((typeof options === "object")){
        if(options.debug){
            bot.debug = options.debug;
        }
        if(options.entrypoint){
            bot.entrypoint = options.entrypoint;
        }
        if(options.description){
            bot.description = options.description;
        }
        if(options.bot){
            bot.name = options.bot;
        }
    }

    return bot;
}


class __lottus {
    #gets = Object.create(null);
    #posts = Object.create(null);
    
    debug = false;
    entrypoint = "main";
    description = "";
    name = "__lottus__";

    /**
     * 
     * @param {string} location 
     * @param {Message|Function} result 
     * @returns {__lottus}
     */
    get(location, result){
        if(typeof location !== "string" || !location){
            throw new Error("location must be a non-empty string");
        }

        if(typeof result === "function" || result instanceof Message){
            this.#gets[location] = result;
            return this;
        }

        throw new Error("func must be a function or Message");
    }

    /**
     * 
     * @param {string} location 
     * @param {Message|Function} result 
     * @returns {__lottus}
     */
    info(location, result){
        return this.get(location, result);
    }

    /**
     * 
     * @param {string} location 
     * @param {Message|Function} result 
     * @returns {__lottus}
     */
    information(location, result){
        return this.get(location, result);
    }

    /**
     * 
     * @param {string} location 
     * @param {Message|Function} result 
     * @returns {__lottus}
     */
    post(location, result){
        if(typeof location !== "string" || !location){
            throw new Error("location must be a non-empty string");
        }

        if(typeof result === "function" || result instanceof Message){
            this.#posts[location] = result;
            return this;
        }

        throw new Error("result must be a function or Message");
    }

    /**
     * 
     * @param {string} location 
     * @param {Message|Function} result 
     * @returns {__lottus}
     */
    form(location, result){
        return this.post(location, result);
    }

    /**
     * 
     * @param {string} location 
     * @param {Message|Function} get 
     * @param {Message|Function} post 
     * @returns 
     */
    at(location, get, post){
        return this.get(location, get).post(location, post);
    }

    /**
     * 
     * @param {object} request 
     * @param {Message} last_message 
     * @returns {Message}
     */
    async process(request, last_message){
        if(this.debug){
            console.log("Lottus.process input", request);
        }

        if(!request){
            request = {}
        }

        if(!last_message){
            last_message = new Message(this.entrypoint);
        } else {
            if(!request.form){
                request.form = last_message.form;
            }
        }

        const result = await this.process_request(request, last_message);

        if(this.debug){
            console.log("Lottus.process output", result);
        }

        return result;
    }

    /**
     * 
     * @param {Request} request 
     * @param {Message} message 
     * @returns {Message}
     */
    async process_request(request, message){
        if(this.debug){
            console.log("Lottus.process_request input", request, message); 
        }

        if(!(message instanceof Message)){
            throw new Error("Argument message must be of type Message")
        }

        const processor = get_processor(get_route_type(message), message.name);

        if(!processor){
            throw new Error("Could not find a processor for", message.name);
        }

        let result = null;
        if(processor instanceof Message){
            result = processor;
        }else if(typeof processor === "function"){
            result = await processor(request, message);
        }else{
            throw new Error(method + " " + location +" must be a function or Message");
        }

        if(this.debug){
            console.log("process_request output", result); 
        }

        if(!result || !(result instanceof Message)){
            throw new Error("Processor for " + request.method + " " + message.name + " must return a Response object");
        }

        return result;
    }

    get gets(){
        return this.#gets;
    }

    get posts(){
        return this.#posts;
    }

    /**
     * 
     * @param {__blueprint} bp 
     */
    add_blueprint(bp){
        if(!(bp instanceof __blueprint)){
            throw new Error("bp must be of type __blueprint");
        }

        this.#gets = {...this.#gets, ...bp.infos};
        this.#posts = {...this.#posts, ...bp.forms};
    }
}

/**
 * 
 * @param {object} options 
 * @returns 
 */
function blueprint(options){
    return new __blueprint();
}


class __blueprint {
    #__infos = Object.create(null);
    #__forms = Object.create(null);

    /**
     * 
     * @param {string} location 
     * @param {Message|Message} result 
     * @returns {__blueprint}
     */
    info(location, result){
        if(typeof location !== "string" || !location){
            throw new Error("location must be a non-empty string");
        }

        if(typeof result === "function" || result instanceof Message){
            this.#__infos[location] = result;
            return this;
        }

        throw new Error("func must be a function or Message");
    }

    /**
     * 
     * @param {string} location 
     * @param {Message|Message} result 
     * @returns {__blueprint}
     */
    get(location, result){
        this.info(location, result);

        return this;
    }

    /**
     * 
     * @param {string} location 
     * @param {Message|Message} result 
     * @returns {__blueprint}
     */
    information(location, result){
        this.info(location, result);

        return this;
    }

    /**
     * 
     * @param {string} location 
     * @param {Message|Message} result 
     * @returns {__blueprint}
     */
    form(location, result){
        if(typeof location !== "string" || !location){
            throw new Error("location must be a non-empty string");
        }

        if(typeof result === "function" || result instanceof Message){
            this.#__forms[location] = result;
            return this;
        }

        throw new Error("result must be a function or Message");
    }

    /**
     * 
     * @param {string} location 
     * @param {Message|Function} result 
     * @returns {__blueprint}
     */
    post(location, result){
        this.form(location, result);

        return this;
    }

    /**
     * 
     * @param {string} location 
     * @param {Message|Function} get 
     * @param {Message|Function} post 
     * @returns {__blueprint}
     */
    at(location, get, post){
        this.info(location, get);
        this.form(location, post);

        return this;
    }

    /**
     * 
     * @returns {object}
     */
    get forms(){
        return this.#__forms;
    }

    /**
     * 
     * @returns {object}
     */
    get infos(){
        return this.#__infos;
    }
}


let bot = new __lottus();


const FORM = "FORM";
const INFORMATION = "INFORMATION";

/**
 * 
 * @param {Message} message 
 * @returns {string}
 */
function get_route_type(message){
    return message.form?FORM:INFORMATION;
}

/**
 * 
 * @param {string} route_type 
 * @param {string} location 
 * @returns {Message|Function}
 */
function get_processor(route_type, location){
    if(route_type === INFORMATION){
        return bot.gets[location];
    }

    if(route_type === FORM){
        return bot.posts[location];
    }
}

/**
 * 
 * @param {string} location 
 * @param {object} request 
 * @param {string} method 
 * @returns {Message}
 */
async function redirect(location, request, method = INFORMATION){
    if(typeof location !== "string"){
        throw new Error("Argument location must be a string");
    }

    if(![FORM, INFORMATION].includes(method)){
        throw new Error("Argument method must be a string [INFORMATION|FORM]");
    }

    if(!request || !request.parameters){
        request = {parameters: Object.create(null)}
    }

    let response = new Message(location);
    
    const processor = get_processor(method, location);

    if(!processor){
        throw new Error("Could not find a processor for "+ location);
    }

    let result = null;
    if(processor instanceof Message){
        result = processor;
    }else if(typeof processor === "function"){
        result = await processor(request, response);
    }else{
        throw new Error(method + " " + location +" must be a function or Message");
    }

    if(!result || !(result instanceof Message)){
        throw new Error("Processor must return a Response response");
    }

    if(request.parameters){
        response.parameters = request.parameters;
    }

    return result;
}


class Message {
    /**
     * 
     * @param {string} name 
     */
    body = "";
    footer = "";
    title = "";
    parameters = {};

    constructor(name){
        this.name = name;
    }

    get type(){
        return this.form?FORM:INFORMATION;
    }

    /**
     * 
     * @param {*} options 
     * @example {name: "name", type: "string", next: "surname"}
     */
    addInput(options){
        if(typeof options === "object"){
            if(!this.form){
                this.form = {input: {}};
            }

            if(!this.form.input){
                this.form.input = {};
            }

            if(options.name){
                this.form.input.name = options.name;
            }

            if(options.type){
                this.form.input.type = options.type;
            }

            if(options.next){
                this.form.input.next = options.next;
            }

            if(options.description){
                this.form.input.description = options.description;
            }
        } else {
            this.form = options;
        }
    }

    /**
     * 
     * @param {object} option 
     * @example {key: 1, label: "name", next: "display_name", parameters: {selected: "name"}}
     */
    addOption(option){
        if(!(typeof option === "object")){
            throw new Error("option must be an object");
        }

        if(!this.form){
            this.form = {options: new Map()};
        }
    
        if(!this.form.options){
            this.form.options = new Map();
        }
    
        if(option.key === undefined || option.key === null){
            option.key = this.form.options.size + 1;
        }
    
        const label = option.label;
        const next = option.next;
        const parameters = option.parameters;

        this.form.options.set(option.key.toString(), {label, next, parameters});
    }

    /**
     * 
     * @param {object} option 
     * @example {label: "name", next: "display_name", parameters: {selected: "name"}}
     */
    addAutoOption(option){
        if(!this.form){
            this.form = {options: new Map()};
        }
    
        if(!this.form.options){
            this.form.options = new Map();
        }
    
        let key = this.form.options.size + 1;

        const label = option.label;
        const next = option.next;
        const parameters = option.parameters;
    
        this.form.options.set(key.toString(), {label, next, parameters});
    }
}

/**
 * 
 * @param {object} req 
 * @param {Message} res 
 * @returns {Message}
 */
async function options_processor(req, res){
    const options = req.form?.options;

    if(options){
        const option = options.get(req.prompt);

        if(option){
            req.selected_option = option;
            let next = req.form?.next;

            if(req.selected_option.next){
                next = req.selected_option.next;
            }

            if(!option.parameters){
                option.parameters = {};
            }

            req.parameters = {...req.parameters, ...option.parameters};

            return await redirect(next, req);
        } else {
            res.error = "You selected an invalid option";
        }
    } else {
        res.error = "The form has no input nor options";
    }

    return res;
}

/**
 * 
 * @param {object} req 
 * @param {Message} res 
 * @returns {Message}
 */
async function input_processor(req, res){
    const input = req.form?.input;

    if(input){
        const name = input.name;
        const value = req.prompt;
        
        if(input.type === "number"){
            if(!parseFloat(value)){
                res.error = "Please provide a number";

                return res;
            }
        }

        let parameter = {}
        parameter[name] = value;

        req.parameters = {...req.parameters, ...parameter};

        let next = input?.next;

        return await redirect(next, req);
    }

    if(!res.error){
        res.error = "The form has no input form";
    }

    return res;
}

/**
 * 
 * @param {object} req 
 * @param {Message} res 
 * @returns {Message}
 */
async function form_processor(req, res){
    const options = req.form?.options;
    const input = req.form?.input;

    if(options){
        const option = options.get(req.prompt);

        if(option){
            req.selected_option = option;
            let next = req.form?.next;

            if(req.selected_option.next){
                next = req.selected_option.next;
            }

            if(!option.parameters){
                option.parameters = {};
            }

            req.parameters = {...req.parameters, ...option.parameters};

            return await redirect(next, req);
        } else {
            res.error = "You selected an invalid option";
        }
    }

    if(input){
        const name = input.name;
        const value = req.prompt;
        
        if(input.type === "number"){
            if(!parseFloat(value)){
                res.error = "Please provide a number";

                return res;
            }
        }

        let parameter = {}
        parameter[name] = value;

        req.parameters = {...req.parameters, ...parameter};

        let next = input?.next;

        return await redirect(next, req);
    }

    if(!res.error){
        res.error = "The form has no input nor options";
    }

    return res;
}

/**
 * 
 * @param {Message} message 
 * @returns {string}
 */
function format_message(message, parameters){
    let result = "";
    if(!(message instanceof Message)){
        throw new Error("Argument message must be of type Message");
    }

    if(message.title){
        result += message.title + "\n";
    }

    if(message.body){
        result += message.body + "\n";
    }

    if(message.error){
        result += message.error + "\n";
    }

    if(message.form && message.form.options){
        for(const option of message.form.options){
            result += option[0] + " - " + option[1].label + "\n";
        }
    }

    if(message.footer){
        result += message.footer + "\n";
    }

    if(parameters){
        for(const key of Object.keys(parameters)){
            result = result.replace("{{"+key+"}}", parameters[key]);
        }
    }

    return result;
}


class InMemorySessionManager {
    #sessions = new Map();

    /**
     * 
     * @param {string} identifier 
     * @returns {object}
     */
    get(identifier){
        return this.#sessions.get(identifier);
    }

    /**
     * 
     * @param {string} identifier 
     * @param {string} message 
     * @param {object} parameters 
     */
    save(identifier, message, parameters){
        this.#sessions.set(identifier, {message: message, parameters: parameters});
    }

    /**
     * 
     * @param {identifier} identifier 
     */
    close(identifier){
        this.#sessions.delete(identifier);
    }

    get sessions(){
        return this.#sessions;
    }
}


/**
 * 
 * @param {__lottus} bot 
 * @param {InMemorySessionManager} session_manager 
 * @param {string} identifier 
 * @param {object} request 
 * @returns {object}
 */
async function process_w_session(bot, session_manager, identifier, request){
    let session = session_manager.get(identifier);

    if(!session){
        session = {message: null, parameters: null};
    }

    if(session.parameters){
        request.parameters = {...request.parameters, ...session.parameters};
    }

    session.message = await bot.process(request, session.message);
    session.parameters = {...session.parameters, ...session.message.parameters};
    session_manager.save(identifier, session.message, session.parameters);

    if(session.message.close){
        session_manager.close(identifier);
    }

    return session;
}