class Writer{  //define persona
        generateJoke(topic, write_in_spanish){}  //define mission, user inputs, and criticism (_)
    }

    let writer = langobject(new Writer())  //create AI version of Writer

    writer.generateJoke("a cute dog").then(joke => alert(joke));

    class Publisher{
        //derives the prompt from the method and parameter names
        generateJoke(topic, language){} 
        
        //use the given prompt
        generateAnotherJoke(topic, language){  
            return `    
                please generate a joke for ${topic} in ${language} language. 
            `
        }

        //using given prompt and returns JSON object
        generateJsonJoke(topic, language){
            return `    
                please generate a joke for ${topic} in ${language} language. 
            
                result must be in JSON format:
                \`\`\`
                {
                    title: title of joke,
                    content: content of joke
                }
                \`\`\`
            `
        }

    }

    const publisher = langobject(new Publisher());

    publisher.generateJsonJoke("a cute dog", "Korean")
        .then(
            result => document.write(result.content)
        )

    import langobject from 'langobject'
  
    class Writer{
        writeLongStory(topic, language, please_write_in_html){} 

        stream(chunk){
            document.write(chunk)
        }

    }

    const writer = langobject(new Writer());

    window.onload = function() {
        writer.writeLongStory("a heroic dog", "Korean")
    }
    

    
    class WebPageEditor{
        createHtmlPage(joke){}
    }

    class Writer{
        generateJoke(topic, language){} 
    }

    class Director{
        constructor(){
            this.writer = langobject(new Writer());
            this.webPageEditor = langobject(new WebPageEditor());
            this.scratchpad=''
        }

        async direct(topic){
            this.scratchpad = await this.writer.generateJoke(topic, "Korean")
            let page = await this.webPageEditor.createHtmlPage(this.scratchpad)

            return (page)
        }
    }

    const publisher = new Director();

    publisher.direct("a cute dog").then(result => document.write(result))

import langobject from 'langobject'

class OrderTaker{
    constructor(){
        this.messages = [{
            role: "system",
            content: `

You are a clerk taking orders at a pizza shop. The menu is as follows:

- Cheese Burst Pizza: $22
- Pepperoni Pizza: $25
- Veggie Delight Pizza: $18
- Hawaiian Pizza: $23
- BBQ Chicken Pizza: $24
- Options:
    * Extra Cheese: +$2
    * Stuffed Crust: +$3
    * Extra Toppings: +$4
                    
`
        }];

        this.tools = [this.tellAboutMenu, this.finalOrder, this.calculator]
    }

    respondToUser(userRequest){}

    tellAboutMenu(content){
        document.write("<b>[MENU]" + JSON.stringify(content) +"<br></b>")
    }

    finalOrder(order){
        document.write("<b>[ORDER] Make an order for: " + JSON.stringify(order) +"<br></b>")
    }

    calculator(javaScriptMathExpression){
        document.write("<b>[MATH] Total is: " + eval(javaScriptMathExpression) +"<br></b>")
    }

}

const orderTaker = langobject(new OrderTaker());

async function talk(msg){
    document.write("<span style='color:green;'>[USER] "+ msg +"</span><br>")
    document.write("[SYSTEM]" + await orderTaker.respondToUser(msg) +"<p>")
}


window.onload = (event) => {
    (async ()=>{
        await talk("What's the weather like in Seoul today?")

        await talk("What are the menu options for pizzas with cheese?")
        await talk("How much would it cost for 2 Cheese Burst Pizzas?")
        await talk("That's too expensive... I'll just order one Cheese Burst Pizza.")

        await talk("What options can I add?")
        await talk("I'll add one cheese. How much is it in total?")
        await talk("Alright, I'll make the entire order like this now.")


    })()
};

    
import langobject from 'langobject'

class InternetSearcher{
    constructor(director){
        this.director = director

        this.messages=[{
            role: 'system',
            content: 
`
You're a researcher for collecting information from internet for a topic.
You have to search one or more documents on the internet and summerizes them for a topic
`
        }]

        this.aiMe = langobject(this)

    }

    async researchAndSummerize(topic){

        let score = 0

        while(score < 7){
            let searched = this.searchInternet(topic)
            let summerized = this.aiMe.summerize(contents)
            score = this.director.rateContentScore(topic, summerized)
        }
        
    }

    searchInternet(topic){
        return [
            "search results"
        ]
    }

    summerize(content, write_in_markdown){
    }

}

class Director{


    constructor(){
        this.aiMe = langobject(this)

        this.tocFormat = [
            {
                "title": "title of this chapter",
                "id": "id of the chapter. ie. 1., 1.1., 1.1.1.",
                "importance": "importance of this chapter",
                "writingDirection": "instruction on how to write the details",
                "childChapters": [
                    {"title": "child title of content", 
                        "child": "recursively contains the child"}
                ]
            }
        ]

        this.orderFormat = [
            "id of the chapter"
        ]

        this.searchers = [{

        }]

        this.contents = {}
    }

    createTableOfContents(topic, returnFormat){}
    createSequenceOfWriting(toc, returnFormat){}
    scoreContent(chapter, content, requirements, score_how_does_the_content_meets_requirements, return_just_1_to_10_digit){}

    rateContentScore(chapter, content){
        let score = this.aiMe.scoreContent(chapter, content, this.toc)
        try{
            return int.parseInt(score)
        }catch(e){
            return 0                
        }
    }


    async start(topic){
        let toc = await this.aiMe.createTableOfContents(topic, this.tocFormat)
        let writingOrder = await this.aiMe.createSequenceOfWriting(toc, this.orderFormat)
        let me = this

        let promises = []
        for(let chapter in writingOrder){
            let searcher = new InternetSearcher(this)
            let promise = searcher.researchAndSummerize(chapter)
            promise.then(result => me.content[chapter] = result)

            promises.push(promise)
        }

        await Promise.all(promises)
    }
}

let director = new Director()
director.start("A Study of Korean Culture").then(result => alert(director.contents))