import openai
import json


# Example dummy function hard coded to return the same weather
# In production, this could be your backend API or an external API
def get_current_weather(location, unit="fahrenheit"):
    """Get the current weather in a given location"""
    weather_info = {
        "location": location,
        "temperature": "72",
        "unit": unit,
        "forecast": ["sunny", "windy"],
    }
    return json.dumps(weather_info)


def run_conversation():
    # Step 1: send the conversation and available functions to GPT
    messages = [{"role": "user", "content": "What's the weather like in Boston?"}]
    functions = [
        {
            "name": "get_current_weather",
            "description": "Get the current weather in a given location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    },
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
                },
                "required": ["location"],
            },
        }
    ]
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo-0613",
        messages=messages,
        functions=functions,
        function_call="auto",  # auto is default, but we'll be explicit
    )
    response_message = response["choices"][0]["message"]

    # Step 2: check if GPT wanted to call a function
    if response_message.get("function_call"):
        # Step 3: call the function
        # Note: the JSON response may not always be valid; be sure to handle errors
        available_functions = {
            "get_current_weather": get_current_weather,
        }  # only one function in this example, but you can have multiple
        function_name = response_message["function_call"]["name"]
        fuction_to_call = available_functions[function_name]
        function_args = json.loads(response_message["function_call"]["arguments"])
        function_response = fuction_to_call(
            location=function_args.get("location"),
            unit=function_args.get("unit"),
        )

        # Step 4: send the info on the function call and function response to GPT
        messages.append(response_message)  # extend conversation with assistant's reply
        messages.append(
            {
                "role": "function",
                "name": function_name,
                "content": function_response,
            }
        )  # extend conversation with function response
        second_response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo-0613",
            messages=messages,
        )  # get a new response from GPT where it can see the function response
        return second_response


print(run_conversation())

const functionDefinition = [
  {
    name: 'geocoding',
    description: "指定された場所の緯度経度情報(lat,lng)を取得します。",
    parameters:{
      type: 'object',
      properties: {
        location :{
          type: 'string',
          desciption: '緯度経度が知りたい地名を記入してください。'
        }
      },
      required:['location']
    },
  },
  {
    name: 'get_map',
    description: "緯度経度を引数に地図URLを返却します。",
    parameters:{
      type: 'object',
      properties:{
        lat:{
          type: 'number',
          desciption: '地図を知りたい地点のLATを指定してください。'
        },
        lng:{
          type: 'number',
          description: '地図を知りたい地点のLNGを指定してください。',
        }
      },
      required:['lat','lng']
    }
  }  
]

const executeFunction = async (functionCall:any):Promise<ChatCompletionRequestMessage> =>{
  const functionName = functionCall.name;
  if(functionName === 'geocoding'){
    return {
      role: 'function',
      name: functionName,
      content: '{"lat":35.681236,"lng":139.767125}'
    }    
  }else if(functionName === 'get_map'){
    const args = JSON.parse(functionCall.arguments!);
    const mapUrl = `https://www.google.com/maps/search/?api=1&query=${args.lat},${args.lng}`;
    return {
      role: 'function',
      name: functionName,
      content: mapUrl,
    }    
  }
  throw new Error('not implemented');
};

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const OPENAI_MODEL = "gpt-3.5-turbo-0613";

const configuration = new Configuration({
  apiKey: OPENAI_API_KEY,
});

const chatRecursive = async (sessionMessages:[ChatCompletionRequestMessage]) => {
  const openai = new OpenAIApi(configuration);  
  const response = await openai.createChatCompletion({
    model: OPENAI_MODEL,
    messages : sessionMessages,
    functions: functionDefinition,
    function_call: 'auto'
  })
  const message = response.data.choices[0].message!;
  if(message.content){
    console.log(`user-response:${message.content}`);
    return;
  }else if(message.function_call){
    console.log(`function-start:${message.function_call.functionName},args:${message.function_call.arguments}`);
    const functionMessage = await executeFunction(message.function_call);
    console.log(`function-message ${functionMessage}`);
    sessionMessages.push(message);
    sessionMessages.push(functionMessage);
    await chatRecursive(sessionMessages);
    return ;
  }
}

const chatSession = async(content:string) => {
  console.log(`user-reqest:${content}`);
  const message:ChatCompletionRequestMessage = {
    role: 'user',
    content: content,
  }  
  await chatRecursive([message]);
}

const main = async() => {
  await chatSession('東京駅の地図見せて');
}

user-request:東京駅の地図見せて

function-start:geocoding,args:{"location": "東京駅"}
function-message:{role: 'function',name: 'geocoding',content: '{"lat":35.681236,"lng":139.767125}'}
function-start:get_map,args:{"lat": 35.681236,"lng": 139.767125}
function-message:{role: 'function',name: 'get_map',content: 'https://www.google.com/maps/search/?api=1&query=35.681236,139.767125'}

user-response:
東京駅の地図はこちらです。
[地図を見る](https://www.google.com/maps/search/?api=1&query=35.681236,139.767125)