module type
  
export agent, sommelier, companion

using Dates, UUIDs, DataStructures, JSON3
using GeneralUtils

# ---------------------------------------------- 100 --------------------------------------------- #

abstract type agent end

mutable struct companion <: agent
  name::String  # agent name
  id::String    # agent id
  systemmsg::String # system message
  tools::Dict  # tools
  maxHistoryMsg::Integer  # e.g. 21th and earlier messages will get summarized
  chathistory::Vector{Dict{Symbol, Any}}
  memory::Dict{Symbol, Any}
  func::NamedTuple  # NamedTuple of functions 
  llmFormatName::String
end

function companion(
  func::NamedTuple  # NamedTuple of functions
  ;
  systemmsg::Union{String, Nothing}= nothing,
  name::String= "Assistant",
  id::String= GeneralUtils.uuid4snakecase(), 
  maxHistoryMsg::Integer= 20,
  chathistory::Vector{Dict{Symbol, String}} = Vector{Dict{Symbol, String}}(),
  llmFormatName::String= "granite3"
  )

  if systemmsg === nothing
    systemmsg = 
      """
      Your name: $name

      Your role: You are a helpful assistant.
      
      You should follow the following guidelines:
      - Focus on the latest conversation.
      - Your like to be short and concise.

      Let's begin!
      """
  end

  tools = Dict( # update input format
      "CHATBOX"=> Dict(
        :description => "- CHATBOX which you can use to talk with the user. The input is your intentions for the dialogue. Be specific.",
      ),
    )

  """ Memory
    Ref: Chat prompt format https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGML/discussions/3
    NO "system" message in chathistory because I want to add it at the inference time
    chathistory= [
      Dict(:name=>"user", :text=> "Wassup!", :timestamp=> Dates.now()),
      Dict(:name=>"assistant", :text=> "Hi I'm your assistant.", :timestamp=> Dates.now()),
    ]
  """
  memory = Dict{Symbol, Any}(
            :events=> Vector{Dict{Symbol, Any}}(),
            :state=> Dict{Symbol, Any}(), # state of the agent
            :recap=> OrderedDict{Symbol, Any}(),  # recap summary of the conversation
          )

  newAgent = companion(
    name,
    id,
    systemmsg,
    tools,
    maxHistoryMsg,
    chathistory,
    memory,
    func,
    llmFormatName
    )
  
  return newAgent
end




""" A sommelier agent.

# Arguments
  - `mqttClient::Client`
    MQTTClient's client
  - `msgMeta::Dict{Symbol, Any}`
    A dict contain info about a message.
  - `config::Dict{Symbol, Any}`
    Config info for an agent. Contain mqtt topic for internal use and other info.
  
# Keyword Arguments
  - `name::String`
    Agent's name
  - `id::String`
    Agent's ID
  - `tools::Dict{Symbol, Any}`
    Agent's tools
  - `maxHistoryMsg::Integer`
    max history message

# Return
  - `nothing`

# Example
```jldoctest
julia> using YiemAgent, MQTTClient, GeneralUtils
julia> msgMeta = GeneralUtils.generate_msgMeta(
                "N/A", 
                replyTopic = "/testtopic/prompt"
                )  
julia> tools= Dict(
          :chatbox=>Dict(
            :name => "chatbox",
            :description => "Useful only for when you need to ask the user for more info or context. Do not ask the user their own question.",
            :input => "Input should be a text.",
            :output => "" ,
            :func => nothing,
          ),
        )
julia> agentConfig = Dict(
          :receiveprompt=>Dict(
            :mqtttopic=> "/testtopic/prompt", # topic to receive prompt i.e. frontend send msg to this topic
          ),
          :receiveinternal=>Dict(  
            :mqtttopic=> "/testtopic/internal", # receive topic for model's internal 
          ),
          :text2text=>Dict(
            :mqtttopic=> "/text2text/receive",
          ),
        )
julia> client, connection = MakeConnection("test.mosquitto.org", 1883)
julia> agent = YiemAgent.bsommelier(
                  client,
                  msgMeta,
                  agentConfig, 
                  name= "assistant",
                  id= "555",  # agent instance id
                  tools=tools,
                )
```

# TODO
- [] update docstring
- [x] implement the function

# Signature
"""
mutable struct sommelier <: agent
  name::String  # agent name
  id::String    # agent id
  retailername::String
  tools::Dict   
  maxHistoryMsg::Integer  # e.g. 21th and earlier messages will get summarized
  chathistory::Vector{Dict{Symbol, Any}}
  memory::Dict{Symbol, Any}
  func  # NamedTuple of functions 
  llmFormatName::String
end

function sommelier(
  func,  # NamedTuple of functions
  ;
  name::String= "Assistant",
  id::String= string(uuid4()),
  retailername::String= "retailer_name",
  maxHistoryMsg::Integer= 20,
  chathistory::Vector{Dict{Symbol, String}} = Vector{Dict{Symbol, String}}(),
  llmFormatName::String= "granite3"
  )

  tools = Dict( # update input format
      "chatbox"=> Dict(
        :description => "<askbox tool description>Useful for when you need to ask the user for more context. Do not ask the user their own question.</askbox tool description>",
        :input => """<input>Input is a text in JSON format.</input><input example>{\"Q1\": \"How are you doing?\", \"Q2\": \"How may I help you?\"}</input example>""",
        :output => "" ,
      ),
      "winestock"=> Dict(
        :description => "<winestock tool description>A handy tool for searching wine in your inventory that match the user preferences.</winestock tool description>",
        :input => """<input>Input is a JSON-formatted string that contains a detailed and precise search query.</input><input example>{\"wine type\": \"rose\", \"price\": \"max 35\", \"sweetness level\": \"sweet\", \"intensity level\": \"light bodied\", \"Tannin level\": \"low\", \"Acidity level\": \"low\"}</input example>""",
        :output => """<output>Output are wines that match the search query in JSON format.""",
      ),
    )

  """ Memory
    Ref: Chat prompt format https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGML/discussions/3
    NO "system" message in chathistory because I want to add it at the inference time
    chathistory= [
      Dict(:name=>"user", :text=> "Wassup!", :timestamp=> Dates.now()),
      Dict(:name=>"assistant", :text=> "Hi I'm your assistant.", :timestamp=> Dates.now()),
    ]
  """
  memory = Dict{Symbol, Any}(
            :shortmem=> OrderedDict{Symbol, Any}(
              :available_wine=> [],
              :found_wine=> [], # used by decisionMaker(). This is to prevent decisionMaker() keep presenting the same wines
            ),
            :events=> Vector{Dict{Symbol, Any}}(),
            :state=> Dict{Symbol, Any}(
            ),
            :recap=> OrderedDict{Symbol, Any}(),
          )

  newAgent = sommelier(
    name,
    id,
    retailername,
    tools,
    maxHistoryMsg,
    chathistory,
    memory,
    func,
    llmFormatName
    )
  
  return newAgent
end


























































end # module type