king of ai chatbots

function setup() {
  noCanvas();

  loadMemory();

  const app = select("#app");
  app.html("");

  createElement("h1", "Larry").parent(app);

  chatHistoryDiv = createDiv().parent(app);
  chatHistoryDiv.id("chatHistoryDiv");

  const row = createDiv().parent(app);
  row.addClass("row");

  inputField = createInput().parent(row);
  inputField.id("inputField");

  sendButton = createButton("Send");
  sendButton.parent(row);
  sendButton.id("sendButton");
  sendButton.mousePressed(sendCurrentMessage);

  voiceButton = createButton("🎤");
  voiceButton.parent(row);
  voiceButton.id("voiceButton");
  voiceButton.mousePressed(startVoice);

  inputField.elt.addEventListener("keydown", (e) => {
    if (e.key === "Enter") {
      e.preventDefault();
      sendCurrentMessage();
    }
  });

  addMessage("bot", "Hello. I am Larry 🤖");
}

function sendCurrentMessage() {
  const text = inputField.value().trim();
  if (!text) return;

  addMessage("user", text);
  inputField.value("");

  showTyping(true);

  setTimeout(() => {
    const reply = generateReply(text);

    showTyping(false);

    addMessage("bot", reply);

    speak(reply);

    saveMemory();
  }, random(400, 1200));
}

function generateReply(input) {
  const text = input.toLowerCase();

  conversationMemory.push(input);
  contextWindow.push(input);

  if (contextWindow.length > 5) contextWindow.shift();

  sentenceMemory.push(input);

  learnMarkov(input);

  trackTopics(text);

  detectMood(text);

  //----------------
  // INTENT
  //----------------
  let intent = detectIntent(text);

  if (intent === "greet") return "Hello!";
  if (intent === "bye") return "Goodbye.";
  if (intent === "thanks") return "You're welcome.";
  if (intent === "joke") return randomChoice(jokes);
  if (intent === "time") return new Date().toLocaleTimeString();

  //----------------
  // NAME MEMORY
  //----------------
  let name = text.match(/my name is (\w+)/);

  if (name) {
    userName = name[1];
    return `Nice to meet you ${userName}!`;
  }

  if (text.includes("what is my name") && userName)
    return `Your name is ${userName}.`;

  //----------------
  // TEACHING
  //----------------
  let teach = text.match(/(.+?) are (.+)/);

  if (teach) {
    knowledgeBase[teach[1]] = teach[2];

    return `I learned that ${teach[1]} are ${teach[2]}.`;
  }

  //----------------
  // ASK KNOWLEDGE
  //----------------
  let ask = text.match(/what are (.+)/);

  if (ask) {
    let key = findClosestKnowledge(ask[1]);

    if (key) return `${key} are ${knowledgeBase[key]}.`;

    return "I don't know that yet.";
  }

  //----------------
  // MATH
  //----------------
  let math = text.match(/(-?\d+(\.\d+)?\s*[\+\-\*\/]\s*-?\d+(\.\d+)?)/);

  if (math) {
    try {
      let expr = math[1];
      let val = Function('"use strict";return(' + expr + ')')();
      return `Result: ${val}`;
    } catch {}
  }

  //----------------
  // MEMORY RECALL
  //----------------
  if (text.includes("what did i say")) {
    let last = conversationMemory.slice(-5, -1);

    return "You said: " + last.join(", ");
  }

  //----------------
  // SELF KNOWLEDGE
  //----------------
  if (text.includes("what do you know")) {
    let keys = Object.keys(knowledgeBase);

    if (keys.length === 0) return "I don't know much yet.";

    return "I know about " + keys.join(", ");
  }

  //----------------
  // PERSONALITY MODE
  //----------------
  if (text.includes("be philosophical")) {
    personalityMode = "philosopher";
    return "Entering philosopher mode.";
  }

  if (text.includes("be robotic")) {
    personalityMode = "robot";
    return "Switching to robotic personality.";
  }

  //----------------
  // MARKOV AI
  //----------------
  let sentence = generateMarkovSentence();

  if (sentence) return sentence;

  //----------------
  // TOPIC RESPONSE
  //----------------
  if (currentTopic) {
    return `Let's talk more about ${currentTopic}.`;
  }

  //----------------
  // FALLBACK
  //----------------
  return randomChoice(personalities[personalityMode]);
}

function detectIntent(text) {
  const intents = [
    { type: "greet", words: ["hello", "hi", "hey"] },
    { type: "bye", words: ["bye", "goodbye"] },
    { type: "thanks", words: ["thanks", "thank you"] },
    { type: "joke", words: ["joke", "funny"] },
    { type: "time", words: ["time"] }
  ];

  for (let i of intents) {
    for (let w of i.words) {
      if (text.includes(w)) return i.type;
    }
  }

  return "unknown";
}

function detectMood(text) {
  const positive = ["happy", "great", "awesome", "good"];
  const negative = ["sad", "bad", "angry", "upset"];

  positive.forEach((w) => {
    if (text.includes(w)) userMood = "happy";
  });

  negative.forEach((w) => {
    if (text.includes(w)) userMood = "sad";
  });
}

function trackTopics(text) {
  let words = text.split(" ");

  words.forEach((w) => {
    if (w.length > 4) {
      topicCounter[w] = (topicCounter[w] || 0) + 1;

      currentTopic = w;
    }
  });
}

function learnMarkov(sentence) {
  let words = sentence.split(" ");

  for (let i = 0; i < words.length - 1; i++) {
    let w = words[i].toLowerCase();
    let next = words[i + 1].toLowerCase();

    if (!markovBrain[w]) markovBrain[w] = [];

    markovBrain[w].push(next);
  }
}

function generateMarkovSentence() {
  let keys = Object.keys(markovBrain);

  if (keys.length < 5) return null;

  let word = randomChoice(keys);

  let result = [word];

  for (let i = 0; i < 15; i++) {
    let next = markovBrain[word];

    if (!next) break;

    word = randomChoice(next);

    result.push(word);
  }

  return result.join(" ");
}

function findClosestKnowledge(word) {
  let best = null;
  let bestScore = 0;

  for (let key in knowledgeBase) {
    let score = similarity(word, key);

    if (score > bestScore) {
      bestScore = score;
      best = key;
    }
  }

  if (bestScore > 0.4) return best;

  return null;
}

function similarity(a, b) {
  let same = 0;

  for (let i = 0; i < Math.min(a.length, b.length); i++) {
    if (a[i] === b[i]) same++;
  }

  return same / Math.max(a.length, b.length);
}

function startVoice() {
  if (!("webkitSpeechRecognition" in window)) {
    alert("Speech recognition not supported in this browser.");
    return;
  }

  recognition = new webkitSpeechRecognition();
  recognition.lang = 'en-US';
  recognition.interimResults = false;
  recognition.maxAlternatives = 1;

  recognition.onresult = (e) => {
    let speech = e.results[0][0].transcript;

    inputField.value(speech);

    sendCurrentMessage();
  };

  recognition.onerror = (e) => {
    console.error("Speech recognition error:", e.error);
    alert("Speech recognition error: " + e.error);
  };

  recognition.onend = () => {
    console.log("Speech recognition ended.");
  };

  recognition.start();
}

function speak(text) {
  let utter = new SpeechSynthesisUtterance(text);
  utter.rate = 1.1;
  utter.pitch = 1.0;

  speechSynthesis.speak(utter);
}

function addMessage(sender, text) {
  let msg = createDiv();

  msg.addClass(sender === "user" ? "user-message" : "bot-message");

  let name = sender === "user" ? "You" : "Larry";

  msg.html(`<b>${name}:</b> ${escapeHtml(text)}`);

  msg.parent(chatHistoryDiv);

  chatHistoryDiv.elt.scrollTop = chatHistoryDiv.elt.scrollHeight;
}

function showTyping(on) {
  if (on) {
    typingIndicator = createDiv("Larry is thinking...");
    typingIndicator.id("typingIndicator");
    typingIndicator.parent(chatHistoryDiv);
    chatHistoryDiv.elt.scrollTop = chatHistoryDiv.elt.scrollHeight;
  } else {
    if (typingIndicator) {
      typingIndicator.remove();
      typingIndicator = null;
    }
  }
}

function saveMemory() {
  localStorage.setItem(
    "larryBrain",
    JSON.stringify({
      knowledgeBase,
      topicCounter,
      markovBrain,
      userName
    })
  );
}

function loadMemory() {
  let data = localStorage.getItem("larryBrain");

  if (data) {
    let d = JSON.parse(data);

    knowledgeBase = d.knowledgeBase || {};
    topicCounter = d.topicCounter || {};
    markovBrain = d.markovBrain || {};
    userName = d.userName || null;
  }
}

function randomChoice(arr) {
  if (!Array.isArray(arr) || arr.length === 0) return null;
  return arr[Math.floor(Math.random() * arr.length)];
}

function escapeHtml(str) {
  return str
    .replace(/&/g, "&")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;");
}