// js/utils.js
import { appState } from './state.js';
import { PIXELS_PER_STEP, ZOOM_LEVELS } from './config.js';

/**
 * Helper interna para ler o BPM do input.
 * @returns {number} O BPM atual.
 */
function _getBpm() {
    const bpmInput = document.getElementById("bpm-input");
    return parseFloat(bpmInput.value, 10) || 120;
}

/**
 * Calcula e exporta quantos compassos (beats) existem por compasso (bar).
 * @returns {number} O número de batidas por compasso (ex: 4 para 4/4).
 */
export function getBeatsPerBar() {
     const compassoAInput = document.getElementById("compasso-a-input");
     return parseInt(compassoAInput.value, 10) || 4;
}

/**
 * Calcula e exporta quantos segundos dura uma "batida" (beat).
 * No contexto de BPM, uma "batida" é quase sempre uma semínima (1/4).
 * @returns {number} Duração da batida em segundos.
 */
export function getSecondsPerBeat() {
    return 60.0 / _getBpm();
}

/**
 * Calcula e exporta quantos segundos dura um "step".
 * Baseado na config, um "step" é uma semicolcheia (1/16).
 * Há 4 steps (1/16) por batida (1/4).
 * @returns {number} Duração do step em segundos.
 */
export function getSecondsPerStep() {
    return getSecondsPerBeat() / 4.0; // 4 steps (1/16) por beat (1/4)
}

/**
 * Quantiza (arredonda) um tempo em segundos para o "step" do grid mais próximo.
 * @param {number} timeInSeconds - O tempo arbitrário (ex: 1.234s).
 * @returns {number} O tempo alinhado ao grid (ex: 1.250s).
 */
export function quantizeTime(timeInSeconds) {
    // TODO: Adicionar um toggle global (appState.global.isSnapEnabled)
    
    const secondsPerStep = getSecondsPerStep();
    if (secondsPerStep <= 0) return timeInSeconds; // Evita divisão por zero
    
    const roundedSteps = Math.round(timeInSeconds / secondsPerStep);
    return roundedSteps * secondsPerStep;
}


/**
 * Calcula a quantidade de pixels que representa um segundo na timeline,
 * levando em conta o BPM e o nível de zoom atual.
 * @returns {number} A quantidade de pixels por segundo.
 */
export function getPixelsPerSecond() {
    const bpm = _getBpm(); // Usa a helper interna
    // (bpm / 60) = batidas por segundo
    // * 4 = steps por segundo (assumindo 4 steps/beat)
    const stepsPerSecond = (bpm / 60) * 4; 
    const zoomFactor = ZOOM_LEVELS[appState.global.zoomLevelIndex];
    return stepsPerSecond * PIXELS_PER_STEP * zoomFactor;
}

/**
 * Calcula o número total de steps no sequenciador de patterns.
 * @returns {number} O número total de steps.
 */
export function getTotalSteps() {
  const barsInput = document.getElementById("bars-input");
  const compassoAInput = document.getElementById("compasso-a-input");
  const compassoBInput = document.getElementById("compasso-b-input");

  const numberOfBars = parseInt(barsInput.value, 10) || 1;
  const beatsPerBar = parseInt(compassoAInput.value, 10) || 4;
  const noteValue = parseInt(compassoBInput.value, 10) || 4;
  const subdivisions = Math.round(16 / noteValue);
  
  return numberOfBars * beatsPerBar * subdivisions;
}

/**
 * Garante que apenas números sejam inseridos em um campo de input.
 * @param {Event} event - O evento de input.
 */
export function enforceNumericInput(event) {
  event.target.value = event.target.value.replace(/[^0-9]/g, "");
}

/**
 * Ajusta o valor de um elemento de input com base em um passo (step),
 * respeitando os limites de min/max definidos no elemento.
 * @param {HTMLInputElement} inputElement - O elemento de input a ser ajustado.
 * @param {number} step - O valor a ser adicionado (pode ser negativo).
 */
export function adjustValue(inputElement, step) {
  let currentValue = parseInt(inputElement.value, 10) || 0;
  let min = parseInt(inputElement.dataset.min, 10);
  let max = parseInt(inputElement.dataset.max, 10);
  let newValue = currentValue + step;

  if (!isNaN(min) && newValue < min) newValue = min;
  if (!isNaN(max) && newValue > max) newValue = max;

  inputElement.value = newValue;
  inputElement.dispatchEvent(new Event("input", { bubbles: true }));
}