use JSON::Fast;
use Data::Reshapers;
use Data::TypeSystem;
use LLM::Tooling;
use WWW::Gemini;

my $model = "gemini-2.0-flash";

#| Powers the spinning disco ball.
sub power-disco-ball-impl(
    Int:D $power #= Whether to turn the disco ball on or off.
    ) returns Hash {
    return { status => "Disco ball powered " ~ ($power ?? 'on' !! 'off') };
}
#= A status dictionary indicating the current state.

#| Play some music matching the specified parameters.
sub start-music-impl(
    Int:D $energetic, #=  Whether the music is energetic or not.
    Int:D $loud       #= Whether the music is loud or not.
    ) returns Hash {
    my $music-type = $energetic ?? 'energetic' !! 'chill';
    my $volume = $loud ?? 'loud' !! 'quiet';
    return { music_type => $music-type, volume => $volume };
    #= A dictionary containing the music settings.
}

#| Dim the lights.
sub dim-lights-impl(
    Numeric:D $brightness #= The brightness of the lights, 0.0 is off, 1.0 is full.
    ) returns Hash {
    return { brightness => $brightness };
}
#= A dictionary containing the new brightness setting.

llm-tool-definition(&dim-lights-impl, format => 'json')

# {
#   "function": {
#     "type": "function",
#     "name": "dim-lights-impl",
#     "strict": true,
#     "description": "Dim the lights.",
#     "parameters": {
#       "required": [
#         "$brightness"
#       ],
#       "additionalProperties": false,
#       "type": "object",
#       "properties": {
#         "$brightness": {
#           "type": "number",
#           "description": "The brightness of the lights, 0.0 is off, 1.0 is full."
#         }
#       }
#     }
#   },
#   "type": "function"
# }

my @tools =
{
    :name("power-disco-ball-impl"), 
    :description("Powers the spinning disco ball."), 
    :parameters(
        {
            :type("object")
            :properties( {"\$power" => {:description("Whether to turn the disco ball on or off."), :type("integer")}}), 
            :required(["\$power"]), 
        }), 
},
{
    :name("start-music-impl"), 
    :description("Play some music matching the specified parameters."), 
    :parameters(
        {
            :type("object")
            :properties({
                "\$energetic" => {:description("Whether the music is energetic or not."), :type("integer")}, 
                "\$loud" => {:description("Whether the music is loud or not."), :type("integer")}
            }), 
            :required(["\$energetic", "\$loud"]), 
        }),
},
{
    :name("dim-lights-impl"), 
    :description("Dim the lights."), 
    :parameters(
        {
            :type("object")
            :properties({"\$brightness" => {:description("The brightness of the lights, 0.0 is off, 1.0 is full."), :type("number")}}), 
            :required(["\$brightness"]), 
        }), 
};

deduce-type(@tools)

# Vector(Struct([description, name, parameters], [Str, Str, Hash]), 3)

my %toolConfig =
  functionCallingConfig => {
    mode => "ANY",
    allowedFunctionNames => <power-disco-ball-impl start-music-impl dim-lights-impl>
  };

# {functionCallingConfig => {allowedFunctionNames => (power-disco-ball-impl start-music-impl dim-lights-impl), mode => ANY}}

# User prompt
my $prompt = 'Turn this place into a party!';

# Prepare the API request payload
my @messages = [{role => 'user',parts => [ %( text => $prompt ) ]}, ];

# [{parts => [text => Turn this place into a party!], role => user}]

my $response = gemini-generate-content(
    @messages,
    :$model,
    :@tools,
    :%toolConfig
);

deduce-type($response)

# Struct([candidates, modelVersion, responseId, usageMetadata], [Hash, Str, Str, Hash])

deduce-type($response)

# Struct([candidates, modelVersion, responseId, usageMetadata], [Hash, Str, Str, Hash])

to-json($response)

# {
#   "candidates": [
#     {
#       "avgLogprobs": -0.0012976408004760742,
#       "content": {
#         "parts": [
#           {
#             "functionCall": {
#               "name": "start-music-impl",
#               "args": {
#                 "$energetic": 1,
#                 "$loud": 1
#               }
#             }
#           },
#           {
#             "functionCall": {
#               "name": "power-disco-ball-impl",
#               "args": {
#                 "$power": 1
#               }
#             }
#           },
#           {
#             "functionCall": {
#               "args": {
#                 "$brightness": 0.5
#               },
#               "name": "dim-lights-impl"
#             }
#           }
#         ],
#         "role": "model"
#       },
#       "safetyRatings": [
#         {
#           "probability": "NEGLIGIBLE",
#           "category": "HARM_CATEGORY_HATE_SPEECH"
#         },
#         {
#           "probability": "NEGLIGIBLE",
#           "category": "HARM_CATEGORY_DANGEROUS_CONTENT"
#         },
#         {
#           "probability": "NEGLIGIBLE",
#           "category": "HARM_CATEGORY_HARASSMENT"
#         },
#         {
#           "probability": "NEGLIGIBLE",
#           "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT"
#         }
#       ],
#       "finishReason": "STOP"
#     }
#   ],
#   "usageMetadata": {
#     "candidatesTokensDetails": [
#       {
#         "tokenCount": 30,
#         "modality": "TEXT"
#       }
#     ],
#     "promptTokensDetails": [
#       {
#         "tokenCount": 113,
#         "modality": "TEXT"
#       }
#     ],
#     "promptTokenCount": 113,
#     "candidatesTokenCount": 30,
#     "totalTokenCount": 143
#   },
#   "responseId": "sOxFaOrFF-SfnvgPgITLqQ8",
#   "modelVersion": "gemini-2.0-flash"
# }

my @messages2 = @messages;

# [{parts => [text => Turn this place into a party!], role => user}]

my @toolObjects = [&power-disco-ball-impl, &start-music-impl, &dim-lights-impl].map({ LLM::Tool.new($_) });

.say for @toolObjects

# LLMTool(power-disco-ball-impl, Powers the spinning disco ball.)
# LLMTool(start-music-impl, Play some music matching the specified parameters.)
# LLMTool(dim-lights-impl, Dim the lights.)

my @requestObjects = $response<candidates>»<content>»<parts>.&flatten»<functionCall>.map({ LLM::ToolRequest.new( $_<name>, $_<args>) });

.say for @requestObjects

# LLMToolRequest(start-music-impl, :$loud(1), :$energetic(1), :id(Whatever))
# LLMToolRequest(power-disco-ball-impl, :$power(1), :id(Whatever))
# LLMToolRequest(dim-lights-impl, :$brightness(0.5), :id(Whatever))

.say for @requestObjects.map({ generate-llm-tool-response(@toolObjects, $_) })».output

# {music_type => energetic, volume => loud}
# {status => Disco ball powered on}
# {brightness => 0.5}

.say for @requestObjects.map({ generate-llm-tool-response(@toolObjects, $_) })».Hash('Gemini')

# {functionResponse => {name => start-music-impl, response => {content => {music_type => energetic, volume => loud}}}}
# {functionResponse => {name => power-disco-ball-impl, response => {content => {status => Disco ball powered on}}}}
# {functionResponse => {name => dim-lights-impl, response => {content => {brightness => 0.5}}}}

my $assistant-message = $response<candidates>[0]<content>;
if $assistant-message<parts> {

    # Find function call parts and make corresponding tool objects
    my @requestObjects;
    for |$assistant-message<parts> -> %part {
        if %part<functionCall> {
            @requestObjects.push: LLM::ToolRequest.new( %part<functionCall><name>, %part<functionCall><args> ) 
        }
    }    

    # Add assistance message
    @messages2.push($assistant-message);

    # Compute tool responses
    my @funcParts = @requestObjects.map({ generate-llm-tool-response(@toolObjects, $_) })».Hash('Gemini');

    # Make and add the user response
    my %function-response =
        role => 'user',
        parts => @funcParts;

    @messages2.push(%function-response);
                
    # Send the second request with function result
    my $final-response = gemini-generate-content(
        @messages2,
        :@tools,
        :$model,
        format => "raku"
    );
                
    say "Assistant: ", $final-response<candidates>[0]<content><parts>».<text>.join("\n");

} else {
    say "Assistant: $assistant-message<content>";
}

# Assistant: Alright! I've started some energetic and loud music, turned on the disco ball, and dimmed the lights to 50% brightness. Let's get this party started!