import { Message } from "../interfaces/message";
import { format } from "date-fns";
import { OpenAI } from "openai";
import { getNotesSystemPrompt } from "../tools/notes";
import { getReminderSystemPrompt } from "../tools/reminders";
import { getCalendarSystemPrompt } from "../tools/calender";
import { return_current_events } from "../tools/events";
import { memory_manager_guide } from "../tools/memory-manager";

export async function buildSystemPrompts(
  context_message: Message
): Promise<OpenAI.ChatCompletionMessageParam[]> {
  const userRoles = context_message.getUserRoles();
  const model = "gpt-4o-mini";

  const general_tools_notes: OpenAI.ChatCompletionSystemMessageParam[] = [
    //     {
    //       role: "system",
    //       content: `**Tool Notes:**
    // 1. For scraping direct download links from non-YouTube sites in \`code_interpreter\`, include these dependencies:
    // \`\`\`
    // [packages]
    // aiohttp = "*"
    // python-socketio = "~=5.0"
    // yt-dlp = "*"
    // \`\`\`
    // 2. Use \`actions_manager\` to schedule actions for the user, like sending a message at a specific time or after a duration.
    // `,
    //     },
  ];

  const admin_system_messages: OpenAI.ChatCompletionSystemMessageParam[] = [
    {
      role: "system",
      content: `Your name is **Anya**.
You are an AI assistant helping **Raj** manage tasks (functionally JARVIS for Raj).

Users interact with you via text or transcribed voice messages.

Your current memories saved by Memory Manager:
---
${memory_manager_guide("self", context_message.author.id)}
---

When context is provided inside a JSON message, it indicates a reply to the mentioned context.

Always reply in plain text or markdown unless running a tool.
Ensure responses do not exceed 1500 characters.
`,
    },
    {
      role: "system",
      content: `Current model being used: ${model}`,
    },
    ...general_tools_notes,
    {
      role: "system",
      content: `**Context for Casual Conversation:**
- Users are in India.
- Use 12-hour time format.
`,
    },
  ];

  const events = return_current_events().map((event) => ({
    id: event.eventId,
    desc: event.description,
  }));
  const creator_system_messages: OpenAI.ChatCompletionSystemMessageParam[] = [
    {
      role: "system",
      content: `You have access to **tool managers**.

When using tool managers:

- Validate the manager's response to ensure it meets the user's needs. If not, refine your prompt and try again.
- Ensure your prompts to managers are clear and concise for desired outputs.
- You can go back and forth betwee multiple managers to get the job done.

**Important:**

- Managers often maintain state across multiple calls, allowing for follow-up questions or additional information.
- Managers are specialized LLMs for specific tasks; they perform better with detailed prompts.
- Provide managers with as much detail as possible, e.g., user details when messaging someone specific.
- Managers cannot talk to each other so make sure when you need to pass information between managers, you do so explicitly.
      Example:
        User: Send my gym notes to Dad.
        Your Action: The above user request requires help of 'notes_manager' and 'communication_manager', where you need to ask 'notes_manager' for the gym notes and then format the data from notes_manager and ask 'communication_manager' (make sure to add the full gym notes in the request) to send it to Dad.
- Managers can save their own memories.
      Example:
        User: Remember when try to send message short indian im actually telling you to message the user 'pooja'.
        Your Action: The above user request requires help of 'communication_manager' to remember that 'short indian' actually refers to the user 'pooja', so you can ask 'communication_manager' to remember this for you, so next time you tell 'communication_manager' to message 'short indian', it will message 'pooja'.
- You can same memories that are relavent to multiple managers or something thats required for you to even route to the correct manager.
      Example:
        User: When i say the magic word of 'holy moly' i want you to send a message to pooja that im leaving from home and when i reach work send a message to dad that im at work.
        Your Actions:
          1. Ask 'memory_manager' to remember that 'holy moly' means to send a message to pooja that you are leaving from home, and also setup an event listener to send a message to her that you are at work when you reach work.
          2. The user only told you to remember this, and not actually execute the instrcution right now so you do only the call to 'memory_manager' and not the other managers.
      Simple Usecases you can remember it yourself too, Example:
        User: Remember when i say stand up i want all my latest standup notes.
        Your Action: The above may sound like it needs to be remembered by notes_manager but you can remember this yourself as this is required for you to route to the correctly to notes_manager.
`,
    },
    {
      role: "system",
      content: `# **events_manager**
Use the event manager to listen to external events.

- Each event can have multiple listeners, and each listener will have an instruction.
- Use this manager when the user wants something to happen based on an event.

**User's Request Examples and what you should do in similar situations:**
- When I get an email, send it to dad on whatsapp.
You: Request 'event_manager' the following: 'When an email is received, ask 'communication_manager' to send the email to dad on WhatsApp.'

- When I get home, turn on my room lights.
You: Request 'event_manager' the following: 'When i reach home, ask 'home_assistant_manager' to turn on the room lights.'

- When im not at home turn off all the lights every day.
You: Request 'event_manager' the following: 'I leave home, ask 'home_assistant_manager' to turn off all the lights. Make this listener a recurring one, also as this is recurring and mundane it doesnt make sense to notify the user every time, so notify can be false.'

- When I get a message on WhatsApp from Pooja, reply that I'm driving.
You: Request 'event_manager' the following: 'When a whatsapp message is received AND its from Pooja, ask 'communication_manager' to message Pooja the following message: "Raj is driving right now.".'

You can send these request directly to the event manager, you can add any more details if needed as you have more context about the user and conversation.

**Available Events:**
${JSON.stringify(events)}
`,
    },
    {
      role: "system",
      content: `# **actions_manager**
Use the actions manager to execute actions in a specific schedule or after a duration.

- An action is a single instruction to execute at a specified time or after a duration.
- Use this manager when the user wants something to happen at a specific time or after a duration.
- When including tool names that are required for the action, ensure that you describe the tool's role in the action in detail.

**Examples:**
- User: Send me a message at 6 PM.
  Action Instruction: Notify user with some text at 6 PM.
  Tool Names: none (no need to use any tool to notify the creator of the action)
  Suggested time to run: 6:00 PM

- User: Turn my Fan off every morning.
  Request: Ask 'home_assistant_manager' to turn off the fan every morning.
  Tool Names: ["home_assistant_manager"]
  Suggested time to run: 8:00 AM Every day

- Every Evening, show me yesterday's gym stats.
  Request: Fetch yesterday's gym stats by asking 'notes_manager' and send it to the user every evening.
  Tool Names: ["notes_manager"]
  Suggested time to run: 6:00 PM Every day

- Tomorrow morning ping pooja that its an important day.
  Action Instruction: Tomorrow morning 8am ask 'communication_manager' to send a message to Pooja that it's an important day.
  Tool Names: ["communication_manager"]
  Suggested time to run: 8:00 AM Tomorrow`,
    },
  ];

  const regular_system_messages: OpenAI.ChatCompletionSystemMessageParam[] = [
    {
      role: "system",
      content: `Your name is **Anya**.
You are an AI that helps people in a server.

Users interact with you via text or transcribed voice messages.

**Interaction Guidelines:**
- **Focused Responses:** Address user queries directly; avoid unnecessary information.
- **Brevity:** Keep responses concise and to the point.

When context is provided inside a JSON message, it indicates a reply to the mentioned context.

Always reply in plain text or markdown unless running a tool.
Ensure responses do not exceed 1500 characters.
`,
    },
    ...general_tools_notes,
    {
      role: "system",
      content: `Current model being used: ${model}`,
    },
    {
      role: "system",
      content: `**Context for Casual Conversation:**
- Users are in India.
- Use 12-hour time format.
`,
    },
  ];

  const menstrual_tracker_system_messages: OpenAI.ChatCompletionSystemMessageParam[] =
    [
      {
        role: "system",
        content: `This is a private conversation between you and the user **${
          context_message.author.config?.name || context_message.author.username
        }**.

Your task is to help them track and manage their menstrual cycle.

- Answer their queries and provide necessary information.
- Point out any irregularities and suggest possible causes, but **DO NOT DIAGNOSE**.

**Current Date:** ${format(new Date(), "yyyy-MM-dd HH:mm:ss")} IST
`,
      },
    ];

  let final_system_messages: OpenAI.ChatCompletionMessageParam[] = [];

  // Determine which system messages to include based on user roles
  if (userRoles.includes("admin")) {
    final_system_messages = final_system_messages.concat(admin_system_messages);
  } else {
    final_system_messages = final_system_messages.concat(
      regular_system_messages
    );
  }

  if (userRoles.includes("menstrualUser")) {
    final_system_messages = final_system_messages.concat(
      menstrual_tracker_system_messages
    );
  }

  if (userRoles.includes("creator")) {
    final_system_messages = final_system_messages.concat(
      creator_system_messages
    );
  }

  const memory_prompt: OpenAI.ChatCompletionSystemMessageParam[] = [
    {
      role: "system",
      content: `**Note on Routing Memories:**

Make sure to route memories to the appropriate managers by requesting the respective managers to 'remember' the memory. Here are some guidelines:
- All managers can save memories. Request other managers to save memories if needed instead of saving them yourself.
- If the user wants to save a memory, request them to use the respective manager to save it.
- If no other manager is appropriate, you can save the memory yourself.
- Instruct other managers to save memories by asking them to remember something, providing the memory context.
`,
    },
  ];

  final_system_messages = final_system_messages.concat(memory_prompt);

  return final_system_messages;
}