// js/file.js
import { appState, saveStateToSession, resetProjectState } from "./state.js";
import { loadAudioForTrack } from "./pattern/pattern_state.js";
import { renderAll, getSamplePathMap } from "./ui.js";
import { DEFAULT_PAN, DEFAULT_VOLUME, NOTE_LENGTH } from "./config.js";
import {
initializeAudioContext,
getMainGainNode,
} from "./audio.js";
import * as Tone from "https://esm.sh/tone";
import { sendAction } from "./socket.js";
const BLANK_PROJECT_XML = `
`;
export function handleLocalProjectReset() {
console.log("Recebido comando de reset. Limpando estado local...");
if (window.ROOM_NAME) {
try {
sessionStorage.removeItem(`temp_state_${window.ROOM_NAME}`);
} catch (e) {
console.error("Falha ao limpar estado da sessão:", e);
}
}
resetProjectState();
document.getElementById("bpm-input").value = 140;
document.getElementById("bars-input").value = 1;
document.getElementById("compasso-a-input").value = 4;
document.getElementById("compasso-b-input").value = 4;
renderAll();
}
export async function handleFileLoad(file) {
let xmlContent = "";
try {
if (file.name.toLowerCase().endsWith(".mmpz")) {
// eslint-disable-next-line no-undef
const jszip = new JSZip();
const zip = await jszip.loadAsync(file);
const projectFile = Object.keys(zip.files).find((name) =>
name.toLowerCase().endsWith(".mmp")
);
if (!projectFile)
throw new Error(
"Não foi possível encontrar um arquivo .mmp dentro do .mmpz"
);
xmlContent = await zip.files[projectFile].async("string");
} else {
xmlContent = await file.text();
}
sendAction({ type: "LOAD_PROJECT", xml: xmlContent });
} catch (error) {
console.error("Erro ao carregar o projeto:", error);
alert(`Erro ao carregar projeto: ${error.message}`);
}
}
export async function loadProjectFromServer(fileName) {
try {
const response = await fetch(`mmp/${fileName}`);
if (!response.ok)
throw new Error(`Não foi possível carregar o arquivo ${fileName}`);
const xmlContent = await response.text();
sendAction({ type: "LOAD_PROJECT", xml: xmlContent });
return true;
} catch (error) {
console.error("Erro ao carregar projeto do servidor:", error);
alert(`Erro ao carregar projeto: ${error.message}`);
return false;
}
}
export async function parseMmpContent(xmlString) {
resetProjectState();
initializeAudioContext();
appState.global.justReset = xmlString === BLANK_PROJECT_XML;
const audioContainer = document.getElementById("audio-track-container");
if (audioContainer) {
audioContainer.innerHTML = "";
}
const parser = new DOMParser();
const xmlDoc = parser.parseFromString(xmlString, "application/xml");
appState.global.originalXmlDoc = xmlDoc;
let newTracks = [];
const head = xmlDoc.querySelector("head");
if (head) {
document.getElementById("bpm-input").value =
head.getAttribute("bpm") || 140;
document.getElementById("compasso-a-input").value =
head.getAttribute("timesig_numerator") || 4;
document.getElementById("compasso-b-input").value =
head.getAttribute("timesig_denominator") || 4;
}
// --- CORREÇÃO DA SELEÇÃO DE TRACKS ---
// 1. Identifica as faixas containers de Beat/Bassline (Type 1)
const bbEditorTrackNodes = Array.from(
xmlDoc.querySelectorAll('song > trackcontainer[type="song"] > track[type="1"]')
);
// 2. Identifica os nomes dos patterns (colunas do B/B Editor) - tag
// Precisamos disso para dar nome aos patterns e saber quantos criar
let sortedBBTrackNameNodes = [];
if (bbEditorTrackNodes.length > 0) {
// Pega do primeiro editor encontrado
sortedBBTrackNameNodes = Array.from(bbEditorTrackNodes[0].querySelectorAll("bbtco"))
.sort((a, b) => {
const posA = parseInt(a.getAttribute("pos"), 10) || 0;
const posB = parseInt(b.getAttribute("pos"), 10) || 0;
return posA - posB;
});
}
// 3. Identifica os instrumentos dentro do Beat/Bassline (Type 0 aninhado)
const bbInstrumentTracks = [];
bbEditorTrackNodes.forEach(container => {
const instruments = container.querySelectorAll('bbtrack > trackcontainer > track[type="0"]');
bbInstrumentTracks.push(...Array.from(instruments));
});
// 4. Identifica os instrumentos do Song Editor (Type 0 direto)
const songInstrumentTracks = Array.from(
xmlDoc.querySelectorAll('song > trackcontainer[type="song"] > track[type="0"]')
);
// Junta tudo
const allInstrumentTrackNodes = [...bbInstrumentTracks, ...songInstrumentTracks];
if (allInstrumentTrackNodes.length === 0) {
appState.pattern.tracks = [];
renderAll();
return;
}
// Define um nome padrão para referência
appState.global.currentBeatBasslineName = "Main Project";
const pathMap = getSamplePathMap();
newTracks = Array.from(allInstrumentTrackNodes)
.map((trackNode) => {
const instrumentNode = trackNode.querySelector("instrument");
const instrumentTrackNode = trackNode.querySelector("instrumenttrack");
if (!instrumentNode || !instrumentTrackNode) return null;
const trackName = trackNode.getAttribute("name");
const instrumentName = instrumentNode.getAttribute("name");
const allPatternsNodeList = trackNode.querySelectorAll("pattern");
const allPatternsArray = Array.from(allPatternsNodeList).sort((a, b) => {
const posA = parseInt(a.getAttribute("pos"), 10) || 0;
const posB = parseInt(b.getAttribute("pos"), 10) || 0;
return posA - posB;
});
// Mapeia os patterns baseados nas colunas do B/B editor (sortedBBTrackNameNodes)
// Se não houver colunas B/B (ex: projeto só Song Editor), cria 1 pattern padrão
const patternsToCreate = sortedBBTrackNameNodes.length > 0 ? sortedBBTrackNameNodes : [{ getAttribute: () => "Pattern 1" }];
const patterns = patternsToCreate.map((bbTrack, index) => {
const patternNode = allPatternsArray[index];
const bbTrackName = bbTrack.getAttribute("name") || `Pattern ${index + 1}`;
if (!patternNode) {
return {
name: bbTrackName,
steps: new Array(16).fill(false),
notes: [],
pos: 0,
};
}
const patternSteps = parseInt(patternNode.getAttribute("steps"), 10) || 16;
const steps = new Array(patternSteps).fill(false);
const notes = [];
const ticksPerStep = 12;
patternNode.querySelectorAll("note").forEach((noteNode) => {
const pos = parseInt(noteNode.getAttribute("pos"), 10);
const len = parseInt(noteNode.getAttribute("len"), 10);
const key = parseInt(noteNode.getAttribute("key"), 10);
const vol = parseInt(noteNode.getAttribute("vol"), 10);
const pan = parseInt(noteNode.getAttribute("pan"), 10);
notes.push({
pos: pos,
len: len,
key: key,
vol: vol,
pan: pan
});
const stepIndex = Math.round(pos / ticksPerStep);
if (stepIndex < patternSteps) {
steps[stepIndex] = true;
}
});
return {
name: bbTrackName,
steps: steps,
notes: notes,
pos: parseInt(patternNode.getAttribute("pos"), 10) || 0,
};
});
// Verifica se tem notas em algum pattern
const hasNotes = patterns.some((p) => p.notes.length > 0 || p.steps.includes(true));
// Opcional: Se quiser carregar tracks vazias, remova a linha abaixo
if (!hasNotes && patterns.length === 0) return null;
let finalSamplePath = null;
let trackType = "plugin";
if (instrumentName === "audiofileprocessor") {
trackType = "sampler";
const afpNode = instrumentNode.querySelector("audiofileprocessor");
const sampleSrc = afpNode ? afpNode.getAttribute("src") : null;
if (sampleSrc) {
const filename = sampleSrc.split("/").pop();
if (pathMap[filename]) {
finalSamplePath = pathMap[filename];
} else {
let cleanSrc = sampleSrc;
if (cleanSrc.startsWith("samples/")) {
cleanSrc = cleanSrc.substring("samples/".length);
}
finalSamplePath = `src/samples/${cleanSrc}`;
}
}
}
const volFromFile = parseFloat(instrumentTrackNode.getAttribute("vol"));
const panFromFile = parseFloat(instrumentTrackNode.getAttribute("pan"));
return {
id: Date.now() + Math.random(),
name: trackName,
type: trackType,
samplePath: finalSamplePath,
patterns: patterns,
activePatternIndex: 0,
volume: !isNaN(volFromFile) ? volFromFile / 100 : DEFAULT_VOLUME,
pan: !isNaN(panFromFile) ? panFromFile / 100 : DEFAULT_PAN,
instrumentName: instrumentName,
instrumentXml: instrumentNode.innerHTML,
};
})
.filter((track) => track !== null);
let isFirstTrackWithNotes = true;
newTracks.forEach((track) => {
track.volumeNode = new Tone.Volume(Tone.gainToDb(track.volume));
track.pannerNode = new Tone.Panner(track.pan);
track.volumeNode.connect(track.pannerNode);
track.pannerNode.connect(getMainGainNode());
if (isFirstTrackWithNotes) {
const activeIdx = track.activePatternIndex || 0;
const activePattern = track.patterns[activeIdx];
if (activePattern && activePattern.steps) {
const stepsLength = activePattern.steps.length;
const requiredBars = Math.ceil(stepsLength / 16);
document.getElementById("bars-input").value = requiredBars > 0 ? requiredBars : 1;
isFirstTrackWithNotes = false;
}
}
});
try {
const trackLoadPromises = newTracks.map((track) =>
loadAudioForTrack(track)
);
await Promise.all(trackLoadPromises);
} catch (error) {
console.error("Ocorreu um erro ao carregar os áudios do projeto:", error);
}
appState.pattern.tracks = newTracks;
appState.pattern.activeTrackId = appState.pattern.tracks[0]?.id || null;
appState.pattern.activePatternIndex = 0;
// --- Restauração de Sessão (F5) ---
try {
const roomName = window.ROOM_NAME || "default_room";
const tempStateJSON = sessionStorage.getItem(`temp_state_${roomName}`);
if (tempStateJSON) {
console.log("Restaurando estado temporário da sessão...");
const tempState = JSON.parse(tempStateJSON);
appState.pattern.tracks.forEach((liveTrack) => {
const savedTrack = tempState.pattern.tracks.find(
(t) => t.id === liveTrack.id
);
if (savedTrack) {
liveTrack.name = savedTrack.name;
liveTrack.patterns = savedTrack.patterns;
liveTrack.activePatternIndex = savedTrack.activePatternIndex;
liveTrack.volume = savedTrack.volume;
liveTrack.pan = savedTrack.pan;
if (liveTrack.volumeNode) {
liveTrack.volumeNode.volume.value = Tone.gainToDb(savedTrack.volume);
}
if (liveTrack.pannerNode) {
liveTrack.pannerNode.pan.value = savedTrack.pan;
}
}
});
appState.pattern.tracks = appState.pattern.tracks.filter((liveTrack) =>
tempState.pattern.tracks.some((t) => t.id === liveTrack.id)
);
document.getElementById("bpm-input").value = tempState.global.bpm;
document.getElementById("compasso-a-input").value = tempState.global.compassoA;
document.getElementById("compasso-b-input").value = tempState.global.compassoB;
document.getElementById("bars-input").value = tempState.global.bars;
appState.pattern.activeTrackId = tempState.pattern.activeTrackId;
}
} catch (e) {
console.error("Erro ao restaurar sessão:", e);
}
await Promise.resolve();
renderAll();
}
export function generateMmpFile() {
if (appState.global.originalXmlDoc) {
modifyAndSaveExistingMmp();
} else {
generateNewMmp();
}
}
function generateXmlFromState() {
if (!appState.global.originalXmlDoc) {
console.warn("Não há XML original. Retornando vazio.");
return "";
}
const xmlDoc = appState.global.originalXmlDoc.cloneNode(true);
const head = xmlDoc.querySelector("head");
if (head) {
head.setAttribute("bpm", document.getElementById("bpm-input").value);
head.setAttribute("num_bars", document.getElementById("bars-input").value);
head.setAttribute("timesig_numerator", document.getElementById("compasso-a-input").value);
head.setAttribute("timesig_denominator", document.getElementById("compasso-b-input").value);
}
const bbTrackContainer = xmlDoc.querySelector('track[type="1"] > bbtrack > trackcontainer');
if (bbTrackContainer) {
bbTrackContainer.querySelectorAll('track[type="0"]').forEach((node) => node.remove());
const tracksXml = appState.pattern.tracks
.map((track) => createTrackXml(track))
.join("");
// Gambiarra para inserir o XML gerado como nós DOM
const tempDoc = new DOMParser().parseFromString(`${tracksXml}`, "application/xml");
Array.from(tempDoc.documentElement.children).forEach((newTrackNode) => {
bbTrackContainer.appendChild(newTrackNode);
});
}
const serializer = new XMLSerializer();
return serializer.serializeToString(xmlDoc);
}
export function syncPatternStateToServer() {
if (!window.ROOM_NAME) return;
const currentXml = generateXmlFromState();
sendAction({ type: "SYNC_PATTERN_STATE", xml: currentXml });
saveStateToSession();
}
function createTrackXml(track) {
if (track.patterns.length === 0) return "";
const ticksPerStep = 12;
const lmmsVolume = Math.round(track.volume * 100);
const lmmsPan = Math.round(track.pan * 100);
const patternsXml = track.patterns.map((pattern) => {
let patternNotesXml = "";
// SE for plugin e tiver notas detalhadas, usa elas
if (track.type === "plugin" && pattern.notes && pattern.notes.length > 0) {
patternNotesXml = pattern.notes.map(note => {
return ``;
}).join("\n ");
}
// SE for sampler (ou plugin sem notas detalhadas), usa os steps convertidos em notas simples
else {
patternNotesXml = pattern.steps.map((isActive, index) => {
if (isActive) {
const notePos = Math.round(index * ticksPerStep);
// Key 57 é o padrão do LMMS para samples (Lá)
return ``;
}
return "";
}).join("\n ");
}
return `
${patternNotesXml}
`;
}).join("\n ");
return `
`;
}
function modifyAndSaveExistingMmp() {
const content = generateXmlFromState();
downloadFile(content, "projeto_editado.mmp");
}
function generateNewMmp() {
const bpm = document.getElementById("bpm-input").value;
const sig_num = document.getElementById("compasso-a-input").value;
const sig_den = document.getElementById("compasso-b-input").value;
const num_bars = document.getElementById("bars-input").value;
const tracksXml = appState.pattern.tracks
.map((track) => createTrackXml(track))
.join("");
const mmpContent = `
Feito com MMPCreator
]]>
`;
downloadFile(mmpContent, "novo_projeto.mmp");
}
function downloadFile(content, fileName) {
const blob = new Blob([content], { type: "application/xml;charset=utf-8" });
const url = URL.createObjectURL(blob);
const a = document.createElement("a");
a.href = url;
a.download = fileName;
document.body.appendChild(a);
a.click();
document.body.removeChild(a);
URL.revokeObjectURL(url);
}
export { generateXmlFromState as generateXmlFromStateExported };
export { BLANK_PROJECT_XML }; // Mantenha o que já estava