//Criar uma funcao anonima para nao ser acessivel ao client
const KeypadSimplesIP = (function () {
  // Função para verificar e definir o tema inicial
  const initialThemeMode = sessionStorage.getItem("themeMode") || "light";
  const simplesipStateCall = (initialStateCall) => {
    let stateCall = initialStateCall;
    function getStateCall() {
      return stateCall;
    }

    function setStateCall(newStateCall) {
      stateCall = newStateCall;
      loadThemeMode();
      updateUI();
      return stateCall;
    }

    return { getStateCall, setStateCall };
  };
  //definir os states para cada fase da chamada do keypad
  const stateCurrent = simplesipStateCall("home");
  const simplesipButtons = [
    "1",
    "2",
    "3",
    "4",
    "5",
    "6",
    "7",
    "8",
    "9",
    "*",
    "0",
    "#",
  ];

  //Listeners para testes==============================================
  document.addEventListener("DOMContentLoaded", function () {
    document.getElementById("home").addEventListener("click", () => {
      stateCurrent.setStateCall("home");
    });
    document.getElementById("outgoingcall").addEventListener("click", () => {
      stateCurrent.setStateCall("outgoingcall");
    });
    document.getElementById("incall").addEventListener("click", () => {
      stateCurrent.setStateCall("incall");
    });
    document.getElementById("incomingcall").addEventListener("click", () => {
      stateCurrent.setStateCall("incomingcall");
    });
    document.getElementById("online").addEventListener("click", () => {
      defineStatusAgent("online");
    });
    document.getElementById("busy").addEventListener("click", () => {
      defineStatusAgent("busy");
    });
    document.getElementById("away").addEventListener("click", () => {
      defineStatusAgent("away");
    });
  });
  //==================================================================

  //RECEBENDO CHAMADA
  let otherNumber = "Indefinido";
  UASimplesIP.simplesipEvento.on("incomingcall", function (callerNumber) {
    if (otherNumber) {
      otherNumber = callerNumber;
    }
    stateCurrent.setStateCall("incomingcall");
  });
  //FAZENDO CHAMADA
  UASimplesIP.simplesipEvento.on("outgoingcall", function (callerNumber) {
    if (otherNumber) {
      otherNumber = callerNumber;
    }
    stateCurrent.setStateCall("outgoingcall");
  });
  //EM CHAMADA
  UASimplesIP.simplesipEvento.on("incall", function () {
    stateCurrent.setStateCall("incall");
  });
  //NA HOME
  UASimplesIP.simplesipEvento.on("confirmedEnded", function () {
    stateCurrent.setStateCall("home");
  });
  UASimplesIP.simplesipEvento.on("home", function () {
    stateCurrent.setStateCall("home");
  });

  //==================================================================
  const simplesipCreateContainer = (themeMode) => {
    let simplesipContainer = document.querySelector(".simplesipContainer");

    // Verifica se já existe um container, e se existir, remove-o
    if (simplesipContainer) {
      simplesipContainer.remove();
    }

    simplesipContainer = document.createElement("div");
    simplesipContainer.classList.add("simplesipContainer");
    simplesipContainer.classList.add(themeMode);
    simplesipContainer.id = "simplesipContainer";

    simplesipCreateTitles(simplesipContainer, themeMode);

    updateUI = function () {
      const currentStateCall = stateCurrent.getStateCall();
      document.addEventListener("keydown", handleKeyPress); // Ao
      //cada vez que irei atualizar a tela eu devo remover todo o html do filho
      // e só assim posso estar criando uma nova tela, para n gerar conflitos e bugs

      let titles = document.querySelector(".simplesipTitles");
      if (titles) {
        // Remover todos os próximos irmãos de titles
        let proximoIrmao = titles.nextSibling;
        while (proximoIrmao) {
          let irmaoRemovido = proximoIrmao;
          proximoIrmao = proximoIrmao.nextSibling;
          irmaoRemovido.parentNode.removeChild(irmaoRemovido);
        }
      }

      switch (currentStateCall) {
        case "home":
          simplesipCreateKeypad(simplesipContainer, themeMode);
          break;

        case "outgoingcall":
          simplesipCreateOutgoingCall(simplesipContainer, themeMode);
          break;

        case "incomingcall":
          simplesipCreateIncomingCall(simplesipContainer, themeMode);
          break;

        case "incall":
          simplesipCreateInCall(simplesipContainer, themeMode);
          restartTimer();
          startTimer();
          break;

        case "config":
          simplesipCreateConfigScreen(simplesipContainer, themeMode);
          break;

        default:
          simplesipCreateKeypad(simplesipContainer, themeMode);
          break;
      }

      document.body.appendChild(simplesipContainer);
      defineStatusAgent(currentStatus); //sempre atualiza o status do agente ao mudar de tela
    };

    updateUI();
    return { simplesipCreateContainer };
  };

  const simplesipCreateConfigScreen = (container, themeMode) => {
    document.removeEventListener("keydown", handleKeyPress);
    const configScreen = document.createElement("div");
    configScreen.classList.add("configScreen");
    configScreen.classList.add(themeMode);
    configScreen.id = "configScreen";

    const titleConfig = document.createElement("div");
    titleConfig.id = "titleConfig";
    titleConfig.textContent = "Configurações do usuário";

    const formScreen = document.createElement("form");
    formScreen.id = "form";
    formScreen.method = "post";
    formScreen.action = "";

    const btnSave = document.createElement("button");
    btnSave.classList.add("animationHover");
    btnSave.id = "btnSave";
    btnSave.type = "submit";
    btnSave.textContent = "Conectar";

    const btnCancel = document.createElement("button");
    btnCancel.classList.add("animationHover");
    btnCancel.id = "btnCancel";
    btnCancel.type = "button";
    btnCancel.textContent = "Cancelar";
    btnCancel.addEventListener("click", () => {
      stateCurrent.setStateCall("home");
    });

    const divDados = document.createElement("div");
    divDados.classList.add("divDados");

    const divUnregister = document.createElement("div");
    divUnregister.classList.add("divUnregister");
    const textoUnregister = document.createElement("p");
    textoUnregister.textContent = "Apagar ramal";
    const unregisterBtn = document.createElement("button");
    unregisterBtn.id = "unregister";
    unregisterBtn.addEventListener("click", () => {
      inputServidor.querySelector("input").value = "";
      inputPorta.querySelector("input").value = "";
      inputNome.querySelector("input").value = "";
      inputRamal.querySelector("input").value = "";
      inputSenha.querySelector("input").value = "";
      UASimplesIP.config.NOME = "";
      UASimplesIP.config.PORTA = "";
      UASimplesIP.config.SENHA = "";
      UASimplesIP.config.SERVIDOR = "";
      UASimplesIP.config.RAMAL = "";
      localStorage.clear();
      currentStatus = "unknown";
      stateCurrent.setStateCall("home");
      UASimplesIP.unregister();
    });
    divUnregister.appendChild(textoUnregister);
    divUnregister.appendChild(unregisterBtn);
    // Função para criar elementos <label> com suas respectivas legendas
    const createLabelAndInput = (
      labelText,
      inputName,
      inputType,
      placeholder
    ) => {
      const label = document.createElement("label");
      label.textContent = labelText;

      const input = document.createElement("input");
      input.name = inputName;
      input.type = inputType;
      input.placeholder = placeholder;

      const divInputGroup = document.createElement("div");
      divInputGroup.classList.add("input-group");
      divInputGroup.appendChild(label);
      divInputGroup.appendChild(input);

      return divInputGroup;
    };

    // Criar inputs com suas respectivas legendas
    const inputServidor = createLabelAndInput(
      "Servidor*",
      "servidor",
      "text",
      "0.0.0.0"
    );
    const inputPorta = createLabelAndInput("Porta", "porta", "text", "8088");
    const inputNome = createLabelAndInput(
      "Nome",
      "nome",
      "text",
      "Insira o nome do agente"
    );
    const inputRamal = createLabelAndInput(
      "Ramal*",
      "ramal",
      "text",
      "Insira o ramal do agente"
    );
    const inputSenha = createLabelAndInput(
      "Senha*",
      "senha",
      "password",
      "Insira a senha do ramal"
    );

    // Adicionar botões ao formulário
    const divBtns = document.createElement("div");
    divBtns.classList.add("divBtns");
    divBtns.appendChild(btnCancel);
    divBtns.appendChild(btnSave);

    divDados.appendChild(inputServidor);
    divDados.appendChild(inputPorta);
    divDados.appendChild(inputNome);
    divDados.appendChild(inputRamal);
    divDados.appendChild(inputSenha);

    configScreen.appendChild(titleConfig);
    configScreen.appendChild(divUnregister);
    formScreen.appendChild(divDados);
    formScreen.appendChild(divBtns);

    configScreen.appendChild(formScreen);
    container.appendChild(configScreen);

    // Função para preencher os inputs com os valores do localStorage
    const fillInputsFromLocalStorage = () => {
      inputServidor.querySelector("input").value =
        localStorage.getItem("servidor") || "";
      inputPorta.querySelector("input").value =
        localStorage.getItem("porta") || "";
      inputNome.querySelector("input").value =
        localStorage.getItem("nome") || "";
      inputRamal.querySelector("input").value =
        localStorage.getItem("ramal") || "";
      inputSenha.querySelector("input").value =
        localStorage.getItem("senha") || "";
    };

    // Preencha os inputs com os valores armazenados no localStorage
    fillInputsFromLocalStorage();

    // Adicione um ouvinte de eventos para o evento submit do formulário
    formScreen.addEventListener("submit", function (event) {
      event.preventDefault(); // Evita que o formulário seja enviado normalmente

      // Coleta os valores dos inputs
      const servidor = inputServidor.querySelector("input").value;
      const porta = inputPorta.querySelector("input").value;
      const nome = inputNome.querySelector("input").value;
      const ramal = inputRamal.querySelector("input").value;
      const senha = inputSenha.querySelector("input").value;

      // Armazena os valores no localStorage
      localStorage.setItem("servidor", servidor);
      localStorage.setItem("porta", porta);
      localStorage.setItem("nome", nome);
      localStorage.setItem("ramal", ramal);
      localStorage.setItem("senha", senha);

      // Salva primeiramente os valores nas configurações do agente
      UASimplesIP.config.PROTOCOLO = "ws";
      UASimplesIP.config.SERVIDOR = servidor;
      UASimplesIP.config.PORTA = porta;
      UASimplesIP.config.NOME = nome;
      UASimplesIP.config.RAMAL = ramal;
      UASimplesIP.config.SENHA = senha;

      if (servidor === "" || ramal === "" || senha === "") {
        simplesipCreateAlert(
          container,
          "Por favor, insira os dados necessários"
        );
      } else {
        stateCurrent.setStateCall("home");
        UASimplesIP.start();
      }
    });
  };
  // Variável para controlar se uma tela de alerta já está sendo exibida
  let isAlertDisplayed = false;

  const simplesipCreateAlert = (container, message) => {
    // Verifica se uma tela de alerta já está sendo exibida
    if (isAlertDisplayed) {
      return; // Sai da função se uma tela de alerta já estiver sendo exibida
    }

    const createAlert = document.createElement("div");
    createAlert.classList.add("alertScreen");
    const iconAlert = document.createElement("img");
    iconAlert.src = alertImg;
    const textAlert = document.createElement("p");
    textAlert.textContent = message;
    createAlert.appendChild(iconAlert);
    createAlert.appendChild(textAlert);

    const btnAlert = document.createElement("button");
    btnAlert.id = "btnAlert";
    btnAlert.textContent = "OK";
    btnAlert.addEventListener("click", () => {
      // Remove a tela de alerta ao clicar no botão "OK"
      container.removeChild(createAlert);
      // Atualiza a variável para indicar que a tela de alerta foi removida
      isAlertDisplayed = false;
    });
    createAlert.appendChild(btnAlert);

    // Adiciona a tela de alerta ao contêiner
    container.appendChild(createAlert);

    // Atualiza a variável para indicar que uma tela de alerta está sendo exibida
    isAlertDisplayed = true;
  };

  const simplesipCreateInCall = (container, themeMode) => {
    const simplesipInCall = document.createElement("div");
    simplesipInCall.classList.add("simplesipInCall");
    simplesipInCall.classList.add(themeMode);
    simplesipInCall.id = "simplesipInCall";

    //Adiciona o numero que ligou ao display
    const bnEndCall = createButtonEndCall(handleEndCall);
    const bnMute = createButtonMute(handleMute);
    const bnKeypad = createButtonKeypad(handleKeypad);
    const bnTransfer = createButtonTransfer(handleTransfer);
    const keyPadIncall = createKeypadIncall();

    //Configura outro display pra mostrar com quem está falando
    const displayOtherNumber = document.createElement("div");
    const userIcon = document.createElement("img");
    userIcon.src = userImg;
    userIcon.width = 20;
    userIcon.height = 20;
    displayOtherNumber.appendChild(userIcon);
    displayOtherNumber.classList.add("displayOtherNumber");
    displayOtherNumber.id = "displayOtherNumber";
    displayOtherNumber.appendChild(userIcon);

    const otherNumberText = document.createElement("span");
    otherNumberText.textContent = otherNumber;
    displayOtherNumber.appendChild(otherNumberText);

    //Cria display que mostra todas as opções da chamada
    const displayInCall = document.createElement("div");
    displayInCall.classList.add("displayInCall");
    displayInCall.id = "displayInCall";
    displayInCall.appendChild(bnMute);
    displayInCall.appendChild(bnKeypad);
    displayInCall.appendChild(bnTransfer);
    displayInCall.appendChild(bnEndCall);

    simplesipCreateDisplayContainer(container, themeMode);
    const display = document.getElementById("displayContainer");
    simplesipInCall.appendChild(displayOtherNumber);
    simplesipCreateTimer(simplesipInCall);
    simplesipInCall.appendChild(keyPadIncall);
    simplesipInCall.appendChild(displayInCall);
    container.appendChild(simplesipInCall);
    //classe adicionada para adaptar o display durante a ligação
    display.classList.add("incallDisplay");
  };

  const createKeypadIncall = () => {
    const keyPadIncall = document.createElement("div");
    keyPadIncall.classList.add("keyPadIncall");
    keyPadIncall.id = "keyPadIncall";

    simplesipButtons.forEach((element) => {
      const simplesipButton = document.createElement("button");
      simplesipButton.textContent = element;
      simplesipButton.classList.add("simplesip-bn");
      simplesipButton.addEventListener("click", () => handleClick(element));
      keyPadIncall.appendChild(simplesipButton);
    });

    return keyPadIncall;
  };

  const createButtonKeypad = (event) => {
    const buttonKeypad = document.createElement("button");
    buttonKeypad.classList.add("buttonKeypad");
    buttonKeypad.id = "buttonKeypad";
    const buttonKeypadImg = document.createElement("img");
    buttonKeypadImg.src = keypadImg;
    buttonKeypadImg.width = 30;
    buttonKeypadImg.height = 30;
    buttonKeypad.appendChild(buttonKeypadImg);
    buttonKeypad.addEventListener("click", () => {
      event();
    });

    return buttonKeypad;
  };

  const createButtonTransfer = (event) => {
    const buttonTransfer = document.createElement("button");
    buttonTransfer.classList.add("transfer");
    buttonTransfer.id = "transfer";
    const buttonTransferImg = document.createElement("img");
    buttonTransferImg.src = transferImg;
    buttonTransferImg.width = 30;
    buttonTransferImg.height = 30;
    buttonTransfer.appendChild(buttonTransferImg);
    buttonTransfer.addEventListener("click", () => {
      event();
    });

    return buttonTransfer;
  };

  const createButtonMute = (event) => {
    const buttonMute = document.createElement("button");
    buttonMute.classList.add("mute");
    buttonMute.id = "mute";
    const buttonMuteImg = document.createElement("img");
    buttonMuteImg.src = muteImg;
    buttonMuteImg.width = 30;
    buttonMuteImg.height = 30;
    buttonMute.appendChild(buttonMuteImg);
    buttonMute.addEventListener("click", () => {
      event();
    });

    return buttonMute;
  };

  const createButtonEndCall = (event) => {
    const buttonEndCall = document.createElement("button");
    buttonEndCall.classList.add("endCall");
    buttonEndCall.classList.add("animationHover");
    buttonEndCall.id = "endCall";
    const buttonEndCallImg = document.createElement("img");
    buttonEndCallImg.src = rejeitarChamadaImg;
    buttonEndCallImg.width = 30;
    buttonEndCallImg.height = 30;
    buttonEndCall.appendChild(buttonEndCallImg);
    buttonEndCall.addEventListener("click", () => {
      event();
    });

    return buttonEndCall;
  };

  const createButtonCall = (event) => {
    const simplesipButtonTelephone = document.createElement("button");
    simplesipButtonTelephone.classList.add("telephone");
    simplesipButtonTelephone.classList.add("animationHover");
    simplesipButtonTelephone.id = "telephone";
    simplesipButtonTelephone.addEventListener("click", () => {
      event();
    });
    const simplesipButtonTelephoneImg = document.createElement("img");
    simplesipButtonTelephoneImg.src = fazerChamadaImg;
    simplesipButtonTelephoneImg.width = 30;
    simplesipButtonTelephoneImg.height = 30;
    simplesipButtonTelephone.appendChild(simplesipButtonTelephoneImg);

    return simplesipButtonTelephone;
  };

  const simplesipCreateIncomingCall = (container, themeMode) => {
    const numberIncomingCall = document.createElement("div");
    numberIncomingCall.classList.add("numberIncomingCall");
    numberIncomingCall.classList.add(themeMode);
    numberIncomingCall.id = "numberIncomingCall";
    numberIncomingCall.textContent = "Recebendo chamada de " + otherNumber;
    container.appendChild(numberIncomingCall);

    const simplesipIncomingCall = document.createElement("div");
    simplesipIncomingCall.classList.add("simplesipIncomingCall");
    simplesipIncomingCall.classList.add(themeMode);
    simplesipIncomingCall.id = "simplesipIncomingCall";
    const bnAcceptCall = createButtonCall(handleAcceptCall);
    const bnEndCall = createButtonEndCall(handleRejectCall);
    bnAcceptCall.style.gridColumn = 1;
    bnAcceptCall.style.animation = "pulse 1s infinite ease-in-out";
    bnEndCall.style.gridColumn = 2;
    bnEndCall.style.animation = "pulse 1s infinite ease-in-out";
    simplesipIncomingCall.appendChild(bnAcceptCall);
    simplesipIncomingCall.appendChild(bnEndCall);

    container.appendChild(simplesipIncomingCall);
  };

  const simplesipCreateOutgoingCall = (container, themeMode) => {
    document.removeEventListener("keydown", handleKeyPress);
    const numberOutgoingCall = document.createElement("div");
    numberOutgoingCall.classList.add("numberOutgoingCall");
    numberOutgoingCall.classList.add(themeMode);
    numberOutgoingCall.id = "numberOutgoingCall";
    if (storedNumberCall != "") {
      numberOutgoingCall.textContent = "Ligando para " + storedNumberCall;
    } else {
      numberOutgoingCall.textContent = "Digite um número e tente novamente";
    }
    container.appendChild(numberOutgoingCall);

    const simplesipOutgoingCall = document.createElement("div");
    simplesipOutgoingCall.classList.add("simplesipOutgoingCall");
    simplesipOutgoingCall.classList.add(themeMode);
    simplesipOutgoingCall.id = "simplesipOutgoingCall";

    const bnEndCall = createButtonEndCall(handleEndCall);
    bnEndCall.classList.add("animationHover");
    bnEndCall.style.gridColumn = 2;
    simplesipOutgoingCall.appendChild(bnEndCall);

    container.appendChild(simplesipOutgoingCall);
  };

  let storedNumberCall = "";
  const handleCall = () => {
    const container = document.getElementById("simplesipContainer");
    const numberCall = document.getElementById("display").textContent;
    if (numberCall !== "") {
      storedNumberCall = numberCall;
      UASimplesIP.simplesipEvento.on("error", function () {
        simplesipCreateAlert(
          container,
          "Conecte-se a um ramal antes de fazer uma chamada"
        );
      });
      UASimplesIP.realizaUmaChamada(storedNumberCall);
    } else {
      //manda o usuario para mensagem de que precisa inserir um numero
      stateCurrent.setStateCall("outgoingcall");
    }
  };

  function handleEndCall() {
    UASimplesIP.simplesipEvento.emit("endCall");
    storedNumberCall = "";
    stateCurrent.setStateCall("home");
  }

  function handleAcceptCall() {
    UASimplesIP.simplesipEvento.emit("accepted");
  }

  function handleRejectCall() {
    UASimplesIP.simplesipEvento.emit("rejected");
    stateCurrent.setStateCall("home");
  }

  let keypadVisible = false;
  function handleKeypad() {
    UASimplesIP.simplesipEvento.emit("");
    if (keypadVisible) {
      document.getElementById("keyPadIncall").style.visibility = "hidden";
      keypadVisible = false;
      document.removeEventListener("keydown", handleKeyPress);
    } else {
      document.getElementById("keyPadIncall").style.visibility = "visible";
      keypadVisible = true;
      document.addEventListener("keydown", handleKeyPress);
    }
  }

  function handleTransfer() {
    UASimplesIP.simplesipEvento.emit("");
  }

  function handleMute() {
    UASimplesIP.simplesipEvento.emit("mute");
    document.getElementById("mute").children[0].src = unmuteImg;
    document.getElementById("mute").removeEventListener("click", handleMute);
    document.getElementById("mute").addEventListener("click", handleUnmute);
  }

  function handleUnmute() {
    UASimplesIP.simplesipEvento.emit("unmute");
    document.getElementById("mute").children[0].src = muteImg;
    document.getElementById("mute").removeEventListener("click", handleUnmute);
    document.getElementById("mute").addEventListener("click", handleMute);
  }

  const simplesipCreateDisplayContainer = (header, themeMode) => {
    const simplesipDisplayContainer = document.createElement("div");
    simplesipDisplayContainer.classList.add("displayContainer");
    simplesipDisplayContainer.classList.add(themeMode);
    simplesipDisplayContainer.id = "displayContainer";
    //add display ao container
    simplesipCreateDisplay(simplesipDisplayContainer, themeMode);
    simplesipCreateClearDisplay(simplesipDisplayContainer, themeMode);
    header.appendChild(simplesipDisplayContainer);
  };

  const simplesipCreateClearDisplay = (header, themeMode) => {
    const simplesipClearDisplay = document.createElement("div");
    simplesipClearDisplay.id = "clearDisplay";
    const clearDisplayImg = document.createElement("img");
    clearDisplayImg.id = "clearDisplayImg";
    clearDisplayImg.src =
      themeMode === "dark" ? limparDisplayLightImg : limparDisplayDarkImg;
    clearDisplayImg.width = 30;
    clearDisplayImg.height = 30;
    simplesipClearDisplay.addEventListener("click", () => {
      clearDisplay();
      haveTextAndClearDisplay(display);
    });
    simplesipClearDisplay.addEventListener("mousedown", function () {
      press = true;

      setTimeout(function () {
        if (press) {
          clearDisplay().clearAll();
        }
      }, 1400);
    });
    simplesipClearDisplay.addEventListener("mouseup", function () {
      press = false;
    });
    simplesipClearDisplay.appendChild(clearDisplayImg);

    header.appendChild(simplesipClearDisplay);
  };

  // Função para lidar com cliques nos botões
  const handleClick = (buttonValue) => {
    const display = document.getElementById("display");
    const maxLength = 11;

    if (display.innerText.length <= maxLength) {
      display.append(buttonValue);
      if (stateCurrent.getStateCall() === "incall") {
        UASimplesIP.simplesipEvento.emit("sendDTMF", buttonValue);
      }
    }
    //chama funcao para verificar se tem texto e exibir botao clear
    haveTextAndClearDisplay(display);
  };

  function haveTextAndClearDisplay(display) {
    const haveText = display.textContent;
    const clearDisplay = document.getElementById("clearDisplay");
    if (haveText.length == 1) {
      clearDisplay.style.display = "flex";
      clearDisplay.style.opacity = 1;
      clearDisplay.style.transition = "opacity 0.3s ease";
      clearDisplay.style.cursor = "pointer";
    } else if (haveText.length == 0) {
      clearDisplay.style.display = "flex";
      clearDisplay.style.opacity = 0;
      clearDisplay.style.cursor = "";
    }
  }

  const clearDisplay = () => {
    const display = document.getElementById("display");
    const currentContent = display.textContent;
    const newContent = currentContent.slice(0, -1);

    display.innerText = newContent;

    function clearAll() {
      display.innerText = "";
    }
    return { clearAll };
  };

  const simplesipCreateHead = (container, themeMode) => {
    const simplesipHead = document.createElement("div");
    simplesipHead.classList.add("simplesipHead");
    simplesipHead.classList.add(themeMode);
    simplesipHead.id = "simplesipHead";
    //add agentLocal display
    simplesipCreateLocalAgentDisplay(simplesipHead);
    simplesipCreateDisplayContainer(simplesipHead, themeMode);
    container.appendChild(simplesipHead);
  };

  var currentStatus = "unknown";
  // Ouvindo o evento 'statusChange' emitido pelo JSSIP
  UASimplesIP.simplesipEvento.on("statusChange", (newStatus) => {
    currentStatus = newStatus;
    defineStatusAgent(currentStatus);
  });

  const defineStatusAgent = (status) => {
    const circleElements = document.querySelectorAll(".circle");

    // Verifica se circleElements não é undefined e se tem comprimento maior que zero
    if (circleElements && circleElements.length > 0) {
      // Remove qualquer uma dessas classes antes de atualizar
      circleElements.forEach((circle) =>
        circle.classList.remove("online", "away", "busy", "unknown", "error")
      );

      // Atualiza conforme o parâmetro passado
      switch (status) {
        case "registered":
          if (circleElements[0]) {
            circleElements[0].classList.add("online");
          }
          break;
        case "registrationFailed":
          if (circleElements[0]) {
            circleElements[0].classList.add("busy");
          }
          break;
        case "unregistered":
          if (circleElements[0]) {
            circleElements[0].classList.add("unknown");
          }
          break;
        default:
          circleElements[0].classList.add("default");
          break;
      }
    }
  };

  const simplesipCreateLocalAgentDisplay = (header) => {
    const agentLocalDisplay = document.createElement("div");
    agentLocalDisplay.id = "agentLocalDisplay";
    const statusAgent = document.createElement("div");
    statusAgent.classList.add("statusAgent");
    const nameAgent = document.createElement("div");
    nameAgent.id = "agentName";

    const defaultCircle = document.createElement("div");
    defaultCircle.classList.add("circle");

    //add o circulo de status
    statusAgent.appendChild(defaultCircle);
    agentLocalDisplay.appendChild(statusAgent);
    //add name agent
    nameAgent.textContent = UASimplesIP.config.NOME
      ? UASimplesIP.config.NOME
      : "Agente";
    agentLocalDisplay.appendChild(nameAgent);
    header.appendChild(agentLocalDisplay);
  };

  const simplesipCreateTitles = (container, themeMode) => {
    const simplesipTitle = document.createElement("div");
    simplesipTitle.classList.add("simplesipTitles");
    simplesipTitle.classList.add(themeMode);
    simplesipTitle.id = "simplesipTitles";
    //add logo da simplesip
    simplesipCreateLogo(simplesipTitle);
    container.appendChild(simplesipTitle);
  };

  const simplesipCreateThemeButton = (titles) => {
    const themeMode = document.createElement("div");
    themeMode.classList.add("themeMode");
    themeMode.classList.add("animationHover");
    themeMode.id = "themeMode";
    const themeModeImg = document.createElement("img");
    themeModeImg.src = darkModeImg;
    themeMode.appendChild(themeModeImg);
    themeMode.addEventListener("click", () => {
      toggleThemeMode();
    });

    titles.appendChild(themeMode);
  };

  const simplesipCreateConfigButton = (titles) => {
    const configBtn = document.createElement("div");
    configBtn.classList.add("configBtn");
    configBtn.classList.add("animationHover");
    configBtn.id = "configBtn";
    const configBtnImg = document.createElement("img");
    configBtnImg.src = engrenagem;
    configBtn.appendChild(configBtnImg);
    configBtn.addEventListener("click", () => {
      handleConfigBtn();
    });
    titles.appendChild(configBtn);
  };

  const simplesipCreateLogo = (titles) => {
    const simplesipLogo = document.createElement("img");
    simplesipLogo.alt = "Logo da SimplesIP";
    simplesipLogo.src = logoSimplesImg;
    simplesipLogo.width = 30;
    simplesipLogo.height = 30;
    //add titulo da simplesip
    const titulo = document.createElement("p");
    titulo.textContent = "Simples IP Softphone";

    const divLogo = document.createElement("div");
    divLogo.classList.add("divLogo");
    divLogo.appendChild(simplesipLogo);
    divLogo.appendChild(titulo);
    titles.appendChild(divLogo);
    simplesipCreateThemeButton(titles);
    simplesipCreateConfigButton(titles);
    simplesipCreateMinimize(titles);
  };

  function handleConfigBtn() {
    stateCurrent.setStateCall("config");
  }

  function toggleThemeMode() {
    const elementosDoKeyPad = document.querySelectorAll(
      "#simplesipContainer *"
    );
    elementosDoKeyPad.forEach(function (elemento) {
      if (elemento.classList.contains("light")) {
        const clearDisplayImg = document.getElementById("clearDisplayImg");
        if (clearDisplayImg) {
          clearDisplayImg.src = limparDisplayLightImg;
        }
        elemento.classList.replace("light", "dark");
      } else if (elemento.classList.contains("dark")) {
        const clearDisplayImg = document.getElementById("clearDisplayImg");

        if (clearDisplayImg) {
          clearDisplayImg.src = limparDisplayDarkImg;
        }
        elemento.classList.replace("dark", "light");
      }
    });

    const simplesipContainer = document.querySelector("#simplesipContainer");
    simplesipContainer.classList.toggle("light");
    simplesipContainer.classList.toggle("dark");

    let isDarkMode = document
      .querySelector("#simplesipContainer")
      .classList.contains("dark");
    sessionStorage.setItem("themeMode", isDarkMode ? "dark" : "light");

    location.reload(false);
  }

  const loadThemeMode = () => {
    const themeMode = sessionStorage.getItem("themeMode");
    const simplesipContainer = document.querySelector("#simplesipContainer");
    if (themeMode === "dark") {
      simplesipContainer.classList.add("dark");
      simplesipContainer.classList.remove("light");
    } else {
      simplesipContainer.classList.add("light");
      simplesipContainer.classList.remove("dark");
    }

    // Aplicar o tema apenas onde há uma classe light ou dark
    const elementosComClasse = document.querySelectorAll(
      "#simplesipContainer .light, #simplesipContainer .dark"
    );
    elementosComClasse.forEach(function (elemento) {
      if (themeMode === "dark") {
        elemento.classList.add("dark");
        elemento.classList.remove("light");
      } else {
        elemento.classList.add("light");
        elemento.classList.remove("dark");
      }
    });
  };

  const simplesipCreateMinimize = (titles) => {
    //add button
    const simplesipMinimize = document.createElement("button");
    simplesipMinimize.classList.add("btn-minimize");
    simplesipMinimize.id = "btn-minimize";
    simplesipMinimize.addEventListener("click", handleMinimize);
    titles.appendChild(simplesipMinimize);
  };

  let isKeyPadMinimized = false;
  const handleMinimize = () => {
    let nextElement =
      document.getElementById("simplesipTitles").nextElementSibling;
    let nextElementId = "";
    let content = "";
    while (nextElement !== null) {
      nextElementId = nextElement.id;
      content = document.getElementById(nextElementId);
      content.style.display = isKeyPadMinimized ? "" : "none";
      nextElement = nextElement.nextElementSibling;
    }
    const btnMinimize = document.getElementById("btn-minimize");
    isKeyPadMinimized = !isKeyPadMinimized; // Inverter a variável aqui
    if (isKeyPadMinimized) {
      btnMinimize.classList.remove("btn-minimize");
      btnMinimize.classList.add("btn-expand");
      document.removeEventListener("keydown", handleKeyPress);
    } else {
      btnMinimize.classList.remove("btn-expand");
      btnMinimize.classList.add("btn-minimize");
      document.addEventListener("keydown", handleKeyPress);
    }
  };

  const simplesipCreateDisplay = (header, themeMode) => {
    const simplesipDisplay = document.createElement("div");
    simplesipDisplay.id = "display";
    simplesipDisplay.classList.add("display");
    simplesipDisplay.classList.add(themeMode);
    header.appendChild(simplesipDisplay);
  };

  const simplesipCreateTimer = (header) => {
    const simplesipTimer = document.createElement("div");
    simplesipTimer.classList.add("timer");
    simplesipTimer.id = "timer";
    simplesipTimer.textContent = "00:00:00";
    header.appendChild(simplesipTimer);
  };

  let segundos = 0;
  let minutos = 0;
  let horas = 0;
  let timer;

  function startTimer() {
    if (!timer) {
      // Verifica se o timer já está em execução
      timer = setInterval(attTimer, 1000);
    }
  }

  function restartTimer() {
    if (timer) {
      clearInterval(timer);
      segundos = 0;
      minutos = 0;
      horas = 0;
      document.getElementById("timer").textContent = "00:00:00";
      timer = null;
    }
  }

  function stopTimer() {
    clearInterval(timer);
  }

  function attTimer() {
    segundos++;
    if (segundos >= 60) {
      segundos = 0;
      minutos++;
      if (minutos >= 60) {
        minutos = 0;
        horas++;
      }
    }
    const formatado = pad(horas) + ":" + pad(minutos) + ":" + pad(segundos);
    let timer = document.getElementById("timer");
    if (timer) {
      timer.textContent = formatado;
    }
  }

  function pad(num) {
    return num < 10 ? "0" + num : num;
  }

  const simplesipCreateKeypad = (container, themeMode) => {
    const simplesipKeypad = document.createElement("div");
    simplesipKeypad.classList.add("simplesipKeypad");
    simplesipKeypad.classList.add(themeMode);
    simplesipKeypad.id = "simplesipKeypad";

    simplesipButtons.forEach((element) => {
      const simplesipButton = document.createElement("button");
      simplesipButton.textContent = element;
      simplesipButton.classList.add("simplesip-bn");
      simplesipButton.addEventListener("click", () => handleClick(element));
      simplesipKeypad.appendChild(simplesipButton);
    });
    const bnAcceptCall = createButtonCall(handleCall);
    bnAcceptCall.style.gridColumn = 2;
    simplesipKeypad.appendChild(bnAcceptCall);
    simplesipCreateHead(container, themeMode);
    container.appendChild(simplesipKeypad);
  };

  const handleKeyPress = (event) => {
    const display = document.getElementById("display");
    const maxLength = 11;
    const keyPress = event.key;
    if (/[0-9 * #]/.test(keyPress)) {
      if (display.innerText.length <= maxLength) {
        if (stateCurrent.getStateCall() === "incall") {
          UASimplesIP.simplesipEvento.emit("sendDTMF", keyPress);
        }
        display.append(keyPress);
      }
      //chama funcao para verificar se tem texto e exibir botao clear
    } else if (keyPress === "Backspace") {
      clearDisplay();
    } else if (keyPress === "Enter" && stateCurrent.getStateCall() === "home") {
      handleCall();
    }
    haveTextAndClearDisplay(display);
  };

  const loadConfig = () => {
    const configuration = UASimplesIP.config;
    configuration.PROTOCOLO = "ws";
    configuration.SERVIDOR = localStorage.getItem("servidor") || "";
    configuration.PORTA = localStorage.getItem("porta") || "";
    configuration.NOME = localStorage.getItem("nome") || "";
    configuration.RAMAL = localStorage.getItem("ramal") || "";
    configuration.SENHA = localStorage.getItem("senha") || "";
  };

  const userImg =
    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB4AAAAeCAYAAAA7MK6iAAAACXBIWXMAAAsTAAALEwEAmpwYAAABKklEQVR4nO2UMU7DQBBFLQpSQgmihivASRCHIFzBHTQIxDV8gLX+W8N2ECpHHAAaBFQgFBTKoCUOogjyGjYJoHzpN/ZKb//M7CTJXL9RxpiWpD2gA7xU7lhr2/7fRKBFUawBXWDwhUt/JirUGNOqgX7AoybXsLyDQO9GAwOXoWBJF9HAknoNwL1oYMLL/O6ZJAae/36PrbXtmUy1Gb7jMuQdZ1m2mExgc5VT3Vwj+TS+lL6PfuAqn/tv0ZPONVWlaboAbEk6AM4k3Ut69QbugFNgX9KmP/tjYJ7nq8CRpIcGC8Rf6tA5t9IY6JxbBk4k9Zvu6U8X6Es6ttYuBUGttRvAzXeBY3wNrNeCJV1FhI7crQVXwxIVLOk2JPGOpKeI4EdgO6jPc/0rvQHiiVTDrTdPvAAAAABJRU5ErkJggg==";

  const transferImg =
    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB4AAAAeCAYAAAA7MK6iAAAACXBIWXMAAAsTAAALEwEAmpwYAAABEElEQVR4nO3WPYrCQBjG8T/CVvb2VnsAC0EvYL1WewPFM4i1HkCUxYOslR+FYMQP7LyAaKWVH81KIMVgnPD6TiRb+MA0IT8eZnhJBt5JOCmgBqyAM7ADusDHq30P+HuwcsJilS9b0AVIC0rVfmGBQ+FuVT5rQf6qC0rVvhoBi4JitW9b0F440WrfvwMjoAF8Ckqd/MZATWFZLH5rwO+I9/ydzICM0odyNGAJe6bBO+u7cqkP5WrAvPF8HDGtnsD/3+KD8Kg8y1FLfSjS4ZjEPVwbA7aega7+1/EDovbtpD6ZlYjpLQiK1T6b1G/Rz9wCB8ii9l+OVx8n/+N42VP7VDAoS+AUXE87T15vXfw7xJYbEKIIsmQ9hbAAAAAASUVORK5CYII=";

  const keypadImg =
    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAB4AAAAeCAYAAAA7MK6iAAAACXBIWXMAAAsTAAALEwEAmpwYAAAAZklEQVR4nO2VQQ6AIAwE59Svi/8UfAbGhHgwLRd70LiTcGHYC+mmIP6IASvQgAqUcZflQ86H/XZKog9pTnBP9CHVCW6JPsT7qiXRh9gI18nwPPHiQj3u6jHq8dcx7WO0j9E+Fi/mAKXv9wzCyGykAAAAAElFTkSuQmCC";

  const alertImg =
    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAACXBIWXMAAAsTAAALEwEAmpwYAAACB0lEQVR4nO2Yz0sCQRiG59LMJQiiQzf7aWVZYkHXDnkpLIKKICSCCPppJVgRUUIQBEFEaBAEQRCBdAw6hLMd/Au6BHbrGv4BCV+4ymim7uzq2kjzwAtz/F5m99mPRUgikUgkEhMASlxA8buaCBlG1QREUT1Q8gkKgXTiEKltQNUCUBzKGj4dHETVALxgGyjk63cBkgBaY0eiAxQ/5Rk+FYqfkcgAxWMFh8+UcCMRgVeEgZI3zQIKjsEjIkg0gGKf9vDsFraQ4NoEjYilVcirTc1HSQytFtLmutsJnqFBNRvjThBWq1BAm74JByvgn3SIqVUoos3d6T5WYG+mVzytgoY2D2btrEDAYxdPq6ChzaO5HlbgeL5bLK0ChzZPFmyswOlil1haBQ5tni11sgLnKx3iaBUKb5s/ElyzsgKXXivPtyFREa0W3TazcrXZzgpc+9r4Pm7UZK1ybZvp3PhbWYHbnRa+AoqJWuXfNlO522tmBe73m/gLKCZpVde2qRAIH1pYgYeARUcBUn6tGtg2S028rFo1tm2WGhysqDZz8xGug5DXqio0eTZQIlEWrfJqMzfbU5llLnk2dAu0RK3q0WZulkcGWIHk2fCjRA1qVa82cxO9aITV0X41yXMJ70LMkFb1atPUUANaVX/K/vXgSuYW/mMB4lKfPwGGh2r7PS+RSCQSVCm+AQ0vLbmgWFIkAAAAAElFTkSuQmCC";

  const engrenagem =
    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADIAAAAyCAYAAAAeP4ixAAAACXBIWXMAAAsTAAALEwEAmpwYAAADfUlEQVR4nO2aS2sUQRDHRyKKbwSjBx8IChpFjA804lG86F09GvQDROItGpCAokE/gZ68bRCXGGb6/+9ZxoOueIhePYhiFoWNJz0kMY9dKZ3gMO7Ozsvd2ZiCgoXt6a5fd1d3TdUYxrL8B0LyLskFklWvApgj2W+0i5As+SE8MG+MdhDTNDcCqNQDITnjOM5KI+tCsicA4pcqpfa3zECt9S4A10zT7AxqR7K3EQjJC0F9mKbZSbJPKbUzVQjLsnaT/OgaUdZan6/XFsBwIxAAt+o9T/IMgM9u25JSam8qENKR33ldH7hvmuZqb9uxsbHNJF+EWJFCPp/f4H02l8utkkmo4V8ThUJhT+oQPn1r2/YB1y+ekvwRAmJxMqZIPtZaH7Isax/J8YD28WFM09zRAGLRoNmwxtd5vgJgOkTbCdu2t0cGCem0TVUAlyODjI6OriX5LkMQ7x3HWW/EEQDHkm6dlCDmAJw0kgjJwQyA3DCSioQTAIotBHmZy+U6jDREjuFWbDEAU4nvEK9orU+1aDUWLMs6mBoIyWcRDSiTHADQDWCdqNb6iOx1978ofT1MBQLAVveFKOzAOX/44RX5j+RIhP6+FYvFNbHeJ9yQ46rEUyRfR4GoVqsrGo0hbaLAAHhO8p5c0kqpE0ETJTN/R8KABPu5HDhA7QmbTHAQfBKb/+qY5HxCxxwIC+GZvJsJx5yv1WnQ62lDVUodjgoiB0CSMQFUUgeJEwe5jp8tkHwE//D5SbZAAHRnZWvNNjuwSxqQApit1el1SZ5J3qkZx6/WehOArzHHmnFt7Q+MduU9XCl1keTtkMmERR0JeyECeBJh5m2SQ5JGItkVK8EXI0QZESdusBKhIUh+jxWipBQ0TsplZ1nWUTmWReW3+ESM7fTIaPcwHkAl1TBefCbi9koLZFpyXqlASDZREnGtWBH+1nHJQiYGIfmghRBVd2WGE0Eopc4mvfHT8hWS52JBOI6zheSXVkPwj5Zt294WGURqIRkwvurTvliFnTBJ7CgZ+IRJ7JLYZPyLsgKAV26bHve2jlVWkNxVgyRgKXHBp06hR+6UQX/MI4WeMFlJSSbUKPR0SARdIwpPr2rlK719AHA64XE9FPD8cU8VID0IX+GnV5JtQe0AXAmxIpdClDR6YxV2mhyXdRlZF3OpfDCwZD7h8GQt2/+jmmUx4stP5T+W3JrYH80AAAAASUVORK5CYII=";

  const darkModeImg =
    "data:image/png;base64,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";

  const muteImg =
    "data:image/png;base64,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";

  const rejeitarChamadaImg =
    "data:image/png;base64,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";

  const fazerChamadaImg =
    "data:image/png;base64,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";

  const limparDisplayDarkImg =
    "data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiA/PjxzdmcgZmlsbD0ibm9uZSIgaGVpZ2h0PSIyMCIgdmlld0JveD0iMCAwIDIwIDIwIiB3aWR0aD0iMjAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PHBhdGggZD0iTTkuMTQ2NDUgNy4xNDY0NkM5LjM0MTcxIDYuOTUxMiA5LjY1ODI5IDYuOTUxMiA5Ljg1MzU1IDcuMTQ2NDZMMTIgOS4yOTI5MUwxNC4xNDY0IDcuMTQ2NDZDMTQuMzQxNyA2Ljk1MTIgMTQuNjU4MyA2Ljk1MTIgMTQuODUzNiA3LjE0NjQ2QzE1LjA0ODggNy4zNDE3MiAxNS4wNDg4IDcuNjU4MzEgMTQuODUzNiA3Ljg1MzU3TDEyLjcwNzEgMTBMMTQuODUzNiAxMi4xNDY1QzE1LjA0ODggMTIuMzQxNyAxNS4wNDg4IDEyLjY1ODMgMTQuODUzNiAxMi44NTM2QzE0LjY1ODMgMTMuMDQ4OCAxNC4zNDE3IDEzLjA0ODggMTQuMTQ2NCAxMi44NTM2TDEyIDEwLjcwNzFMOS44NTM1NSAxMi44NTM2QzkuNjU4MjkgMTMuMDQ4OCA5LjM0MTcxIDEzLjA0ODggOS4xNDY0NSAxMi44NTM2QzguOTUxMTggMTIuNjU4MyA4Ljk1MTE4IDEyLjM0MTcgOS4xNDY0NSAxMi4xNDY1TDExLjI5MjkgMTBMOS4xNDY0NSA3Ljg1MzU3QzguOTUxMTggNy42NTgzMSA4Ljk1MTE4IDcuMzQxNzIgOS4xNDY0NSA3LjE0NjQ2WiIgZmlsbD0iIzIxMjEyMSIvPjxwYXRoIGQ9Ik02LjU4NTggNC42NjQxNkM3LjA0Nzc1IDQuMjM3MTYgNy42NTM2OSA0IDguMjgyNzYgNEgxNS41QzE2Ljg4MDcgNCAxOCA1LjExOTI5IDE4IDYuNVYxMy41QzE4IDE0Ljg4MDcgMTYuODgwNyAxNiAxNS41IDE2SDguMjgyNzZDNy42NTM2OSAxNiA3LjA0Nzc1IDE1Ljc2MjggNi41ODU4IDE1LjMzNThMMi43OTkzNyAxMS44MzU4QzEuNzI4NjYgMTAuODQ2MSAxLjcyODY2IDkuMTUzODggMi43OTkzNyA4LjE2NDE2TDYuNTg1OCA0LjY2NDE2Wk04LjI4Mjc2IDVDNy45MDUzMiA1IDcuNTQxNzUgNS4xNDIyOSA3LjI2NDU4IDUuMzk4NUwzLjQ3ODE2IDguODk4NUMyLjgzNTczIDkuNDkyMzMgMi44MzU3MyAxMC41MDc3IDMuNDc4MTYgMTEuMTAxNUw3LjI2NDU4IDE0LjYwMTVDNy41NDE3NSAxNC44NTc3IDcuOTA1MzIgMTUgOC4yODI3NiAxNUgxNS41QzE2LjMyODQgMTUgMTcgMTQuMzI4NCAxNyAxMy41VjYuNUMxNyA1LjY3MTU3IDE2LjMyODQgNSAxNS41IDVIOC4yODI3NloiIGZpbGw9IiMyMTIxMjEiLz48L3N2Zz4=";

  const limparDisplayLightImg =
    "data:image/svg+xml;base64,PHN2ZyBmaWxsPSJub25lIiBoZWlnaHQ9IjIwIiB2aWV3Qm94PSIwIDAgMjAgMjAiIHdpZHRoPSIyMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cGF0aCBkPSJNOS4xNDY0NSA3LjE0NjQ2QzkuMzQxNzEgNi45NTEyIDkuNjU4MjkgNi45NTEyIDkuODUzNTUgNy4xNDY0NkwxMiA5LjI5MjkxTDE0LjE0NjQgNy4xNDY0NkMxNC4zNDE3IDYuOTUxMiAxNC42NTgzIDYuOTUxMiAxNC44NTM2IDcuMTQ2NDZDMTUuMDQ4OCA3LjM0MTcyIDE1LjA0ODggNy42NTgzMSAxNC44NTM2IDcuODUzNTdMMTIuNzA3MSAxMEwxNC44NTM2IDEyLjE0NjVDMTUuMDQ4OCAxMi4zNDE3IDE1LjA0ODggMTIuNjU4MyAxNC44NTM2IDEyLjg1MzZDMTQuNjU4MyAxMy4wNDg4IDE0LjM0MTcgMTMuMDQ4OCAxNC4xNDY0IDEyLjg1MzZMMTIgMTAuNzA3MUw5Ljg1MzU1IDEyLjg1MzZDOS42NTgyOSAxMy4wNDg4IDkuMzQxNzEgMTMuMDQ4OCA5LjE0NjQ1IDEyLjg1MzZDOC45NTExOCAxMi42NTgzIDguOTUxMTggMTIuMzQxNyA5LjE0NjQ1IDEyLjE0NjVMMTEuMjkyOSAxMEw5LjE0NjQ1IDcuODUzNTdDOC45NTExOCA3LjY1ODMxIDguOTUxMTggNy4zNDE3MiA5LjE0NjQ1IDcuMTQ2NDZaIiBmaWxsPSIjZmZmZmZmIi8+PHBhdGggZD0iTTYuNTg1OCA0LjY2NDE2QzcuMDQ3NzUgNC4yMzcxNiA3LjY1MzY5IDQgOC4yODI3NiA0SDE1LjVDMTYuODgwNyA0IDE4IDUuMTE5MjkgMTggNi41VjEzLjVDMTggMTQuODgwNyAxNi44ODA3IDE2IDE1LjUgMTZIOC4yODI3NkM3LjY1MzY5IDE2IDcuMDQ3NzUgMTUuNzYyOCA2LjU4NTggMTUuMzM1OEwyLjc5OTM3IDExLjgzNThDMS43Mjg2NiAxMC44NDYxIDEuNzI4NjYgOS4xNTM4OCAyLjc5OTM3IDguMTY0MTZMNi41ODU4IDQuNjY0MTZaTTguMjgyNzYgNUM3LjkwNTMyIDUgNy41NDE3NSA1LjE0MjI5IDcuMjY0NTggNS4zOTg1TDMuNDc4MTYgOC44OTg1QzIuODM1NzMgOS40OTIzMyAyLjgzNTczIDEwLjUwNzcgMy40NzgxNiAxMS4xMDE1TDcuMjY0NTggMTQuNjAxNUM3LjU0MTc1IDE0Ljg1NzcgNy45MDUzMiAxNSA4LjI4Mjc2IDE1SDE1LjVDMTYuMzI4NCAxNSAxNyAxNC4zMjg0IDE3IDEzLjVWNi41QzE3IDUuNjcxNTcgMTYuMzI4NCA1IDE1LjUgNUg4LjI4Mjc2WiIgZmlsbD0iI2ZmZmZmZiIvPjwvc3ZnPg==";

  const logoSimplesImg =
    "data:image/png;base64,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";

  const unmuteImg =
    "data:image/png;base64,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";
  window.onload = loadConfig();
  window.onload = simplesipCreateContainer(initialThemeMode);
})();