app.py

import gradio as gr
import struct
import os
import tempfile
import io
import re
import zipfile
import numpy as np
import soundfile as sf
import traceback
from collections import defaultdict


###############################################################################
# MAPEO DE NOTAS
###############################################################################

NOTE_NAMES = {
    'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7, 'A': 9, 'B': 11
}

MIDI_TO_NAME = {}
for _octave in range(-1, 10):
    for _name, _semitone in NOTE_NAMES.items():
        _midi = (_octave + 1) * 12 + _semitone
        if 0 <= _midi <= 127:
            MIDI_TO_NAME[_midi] = f"{_name}{_octave}"
        _midi_sharp = _midi + 1
        if 0 <= _midi_sharp <= 127:
            _sharp_names = {0: 'C#', 2: 'D#', 5: 'F#', 7: 'G#', 9: 'A#'}
            if _semitone in _sharp_names:
                MIDI_TO_NAME[_midi_sharp] = f"{_sharp_names[_semitone]}{_octave}"


def _parse_single_note(note_str):
    pattern = r'^([A-Ga-g])(#|b|♯|♭)?(-?\d+)$'
    m = re.match(pattern, note_str.strip())
    if not m:
        return None
    note_letter = m.group(1).upper()
    accidental = m.group(2) or ''
    octave = int(m.group(3))
    if note_letter not in NOTE_NAMES:
        return None
    if octave > 9 or octave < -1:
        return None
    midi = (octave + 1) * 12 + NOTE_NAMES[note_letter]
    if accidental in ('#', '♯'):
        midi += 1
    elif accidental in ('b', '♭'):
        midi -= 1
    if 0 <= midi <= 127:
        return midi
    return None


def parse_note_name(filename):
    """Extrae nota MIDI y velocidad del nombre del archivo."""
    name = os.path.splitext(filename)[0]
    
    # Formato: Nombre_Nota_Velocidad (e.g., Piano_C3_127, Nylon+Steel_E4_127)
    vel_pattern = r'[_\-\+]([A-Ga-g](?:#|b|♯|♭)?(?:-?\d+))[_\-](\d+)$'
    vel_match = re.search(vel_pattern, name)
    if vel_match:
        note_str = vel_match.group(1)
        velocity = int(vel_match.group(2))
        midi = _parse_single_note(note_str)
        if midi is not None:
            return midi, min(127, max(1, velocity))
    
    # Formato: Nombre_Nota (e.g., Piano_C3)
    vel_pattern2 = r'[_\-\+]([A-Ga-g](?:#|b|♯|♭)?(?:-?\d+))$'
    vel_match2 = re.search(vel_pattern2, name)
    if vel_match2:
        note_str = vel_match2.group(1)
        midi = _parse_single_note(note_str)
        if midi is not None:
            return midi, 127
    
    # Nota al inicio con velocidad: C3_127
    init_vel = re.match(r'^([A-Ga-g](?:#|b|♯|♭)?(?:-?\d+))[_\-](\d+)$', name)
    if init_vel:
        midi = _parse_single_note(init_vel.group(1))
        velocity = int(init_vel.group(2))
        if midi is not None:
            return midi, min(127, max(1, velocity))
    
    # Nota musical con octava en cualquier parte
    pattern = r'([A-Ga-g])(#|b|♯|♭)?(-?\d+)'
    matches = list(re.finditer(pattern, name))
    
    if matches:
        valid_matches = []
        for m in matches:
            note_letter = m.group(1).upper()
            octave = int(m.group(3))
            if octave > 9 or octave < -1:
                continue
            start = m.start()
            if start > 0 and name[start - 1].isdigit():
                continue
            valid_matches.append(m)
        
        if valid_matches:
            preferred = None
            for m in valid_matches:
                start = m.start()
                if start == 0 or (start > 0 and name[start - 1] in ('_', '-', ' ', '+')):
                    preferred = m
                    break
            best = preferred if preferred else valid_matches[0]
            note_letter = best.group(1).upper()
            accidental = best.group(2) or ''
            octave = int(best.group(3))
            if note_letter in NOTE_NAMES:
                midi = (octave + 1) * 12 + NOTE_NAMES[note_letter]
                if accidental in ('#', '♯'):
                    midi += 1
                elif accidental in ('b', '♭'):
                    midi -= 1
                if 0 <= midi <= 127:
                    # Buscar velocidad después de la nota
                    after = name[best.end():]
                    vel_after = re.match(r'[_\-](\d+)', after)
                    if vel_after:
                        vel = int(vel_after.group(1))
                        if 1 <= vel <= 127:
                            return midi, vel
                    return midi, 127
    
    # Número MIDI directo
    num_match = re.search(r'(?<!\d)(\d{2,3})(?!\d)', name)
    if num_match:
        num = int(num_match.group(1))
        if 0 <= num <= 127:
            return num, 127
    
    return None, None


def midi_to_note_name(midi):
    if midi in MIDI_TO_NAME:
        return MIDI_TO_NAME[midi]
    note_names = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
    octave = (midi // 12) - 1
    note = note_names[midi % 12]
    return f"{note}{octave}"


###############################################################################
# AUDIO PROCESSING
###############################################################################

def read_audio_file(audio_bytes):
    try:
        data, sr = sf.read(io.BytesIO(audio_bytes), dtype='float32', always_2d=True)
        num_channels = data.shape[1]
        return data, sr, num_channels
    except Exception:
        return None, None, None


def float_to_pcm16(audio):
    clipped = np.clip(audio, -1.0, 1.0)
    return (clipped * 32767).astype(np.int16).tobytes()


def normalize_audio(audio, target_peak=0.95):
    max_val = np.max(np.abs(audio))
    if max_val > 0.0001:
        return audio * (target_peak / max_val)
    return audio


def trim_silence(audio, sr, threshold_db=-50, margin_ms=5, tail_ms=100):
    threshold = 10 ** (threshold_db / 20.0)
    abs_audio = np.max(np.abs(audio), axis=1)
    margin_samples = int(sr * margin_ms / 1000)
    tail_samples = int(sr * tail_ms / 1000)
    
    start = 0
    for i in range(len(abs_audio)):
        if abs_audio[i] > threshold:
            start = max(0, i - margin_samples)
            break
    
    end = len(abs_audio)
    for i in range(len(abs_audio) - 1, -1, -1):
        if abs_audio[i] > threshold:
            end = min(len(abs_audio), i + tail_samples)
            break
    
    if start >= end:
        return audio
    return audio[start:end]


def apply_fade_in(audio, sr, fade_ms=5):
    """Aplica fade-in suave al inicio."""
    fade_samples = int(sr * fade_ms / 1000)
    fade_samples = min(fade_samples, len(audio))
    if fade_samples > 0:
        fade = np.linspace(0, 1, fade_samples)
        result = audio.copy()
        result[:fade_samples] *= fade[:, np.newaxis]
        return result
    return audio


def apply_fade_out(audio, sr, fade_ms=200):
    """Aplica fade-out suave al final (simula release)."""
    fade_samples = int(sr * fade_ms / 1000)
    fade_samples = min(fade_samples, len(audio))
    if fade_samples > 0:
        fade = np.linspace(1, 0, fade_samples)
        result = audio.copy()
        result[-fade_samples:] *= fade[:, np.newaxis]
        return result
    return audio


###############################################################################
# SF2 WRITER — SOPORTE COMPLETO STEREO + VELOCIDADES + RELEASE
###############################################################################

# Generadores SF2
SF2_GEN_START_ADDRS_OFFSET = 0
SF2_GEN_END_ADDRS_OFFSET = 1
SF2_GEN_STARTLOOP_ADDRS_OFFSET = 2
SF2_GEN_ENDLOOP_ADDRS_OFFSET = 3
SF2_GEN_MOD_LFO_TO_PITCH = 5
SF2_GEN_VIB_LFO_TO_PITCH = 6
SF2_GEN_MOD_ENV_TO_PITCH = 7
SF2_GEN_INITIAL_FILTER_FC = 8
SF2_GEN_INITIAL_FILTER_Q = 9
SF2_GEN_MOD_LFO_TO_FILTER_FC = 10
SF2_GEN_MOD_ENV_TO_FILTER_FC = 11
SF2_GEN_END_ADDRS_COARSE_OFFSET = 12
SF2_GEN_MOD_LFO_TO_VOLUME = 13
SF2_GEN_CHORUS_EFFECTS_SEND = 15
SF2_GEN_REVERB_EFFECTS_SEND = 16
SF2_GEN_PAN = 17
SF2_GEN_DELAY_MOD_LFO = 21
SF2_GEN_FREQ_MOD_LFO = 22
SF2_GEN_DELAY_VIB_LFO = 23
SF2_GEN_FREQ_VIB_LFO = 24
SF2_GEN_DELAY_MOD_ENV = 25
SF2_GEN_ATTACK_MOD_ENV = 26
SF2_GEN_HOLD_MOD_ENV = 27
SF2_GEN_DECAY_MOD_ENV = 28
SF2_GEN_SUSTAIN_MOD_ENV = 29
SF2_GEN_RELEASE_MOD_ENV = 30
SF2_GEN_DELAY_VOL_ENV = 33
SF2_GEN_ATTACK_VOL_ENV = 34
SF2_GEN_HOLD_VOL_ENV = 35
SF2_GEN_DECAY_VOL_ENV = 36
SF2_GEN_SUSTAIN_VOL_ENV = 37
SF2_GEN_RELEASE_VOL_ENV = 38
SF2_GEN_KEY_RANGE = 43
SF2_GEN_VEL_RANGE = 44
SF2_GEN_INITIAL_ATTENUATION = 48
SF2_GEN_SAMPLE_MODES = 54
SF2_GEN_SCALE_TUNING = 56
SF2_GEN_OVERRIDING_ROOT_KEY = 58
SF2_GEN_SAMPLE_ID = 53


def timecents(seconds):
    """Convierte segundos a timecents para SF2."""
    if seconds <= 0:
        return -12000
    tc = int(1200 * np.log2(max(seconds, 0.001)))
    return max(-12000, min(8000, tc))


def centibels(db):
    """Convierte dB a centibels para SF2 attenuation."""
    return int(db * 10)


class SF2Writer:
    def __init__(self, name="SoundFont"):
        self.name = name
        self.samples = []
        self.instruments = []
        self.presets = []

    def add_sample_mono(self, name, pcm_16bit, sample_rate, root_key=60):
        num_points = len(pcm_16bit) // 2
        self.samples.append({
            'name': self._clean(name, 20),
            'pcm': pcm_16bit,
            'num_points': num_points,
            'sr': sample_rate,
            'root': min(127, max(0, root_key)),
            'type': 'mono',
            'link': 0,
            'sf_type': 1,
        })
        return len(self.samples) - 1

    def add_sample_stereo(self, name, pcm_left, pcm_right, sample_rate, root_key=60):
        num_points_l = len(pcm_left) // 2
        num_points_r = len(pcm_right) // 2
        left_idx = len(self.samples)
        right_idx = left_idx + 1
        self.samples.append({
            'name': self._clean(name + '_L', 20),
            'pcm': pcm_left,
            'num_points': num_points_l,
            'sr': sample_rate,
            'root': min(127, max(0, root_key)),
            'type': 'stereo_left',
            'link': right_idx,
            'sf_type': 4,
        })
        self.samples.append({
            'name': self._clean(name + '_R', 20),
            'pcm': pcm_right,
            'num_points': num_points_r,
            'sr': sample_rate,
            'root': min(127, max(0, root_key)),
            'type': 'stereo_right',
            'link': left_idx,
            'sf_type': 8,
        })
        return left_idx, right_idx

    def add_instrument(self, name, zones):
        self.instruments.append({
            'name': self._clean(name, 20),
            'zones': zones,
        })
        return len(self.instruments) - 1

    def add_preset(self, name, preset_num, bank, inst_idx):
        self.presets.append({
            'name': self._clean(name, 20),
            'preset': preset_num,
            'bank': bank,
            'inst_idx': inst_idx,
        })

    def build(self):
        self._calc_offsets()
        info = self._mk_info()
        sdta = self._mk_sdta()
        pdta = self._mk_pdta()
        body = b'sfbk' + info + sdta + pdta
        return b'RIFF' + struct.pack('<I', len(body)) + body

    def _clean(self, s, n):
        cleaned = ''.join(c if 32 <= ord(c) < 127 else '_' for c in str(s))
        return cleaned[:n]

    def _fstr(self, s, n):
        return s.encode('ascii', errors='replace')[:n].ljust(n, b'\x00')

    def _schunk(self, tag, s):
        b = s.encode('ascii', errors='replace') + b'\x00'
        if len(b) % 2:
            b += b'\x00'
        return tag + struct.pack('<I', len(b)) + b

    def _chunk(self, tag, data):
        r = tag + struct.pack('<I', len(data)) + data
        if len(data) % 2:
            r += b'\x00'
        return r

    def _calc_offsets(self):
        off = 0
        for s in self.samples:
            s['start'] = off
            s['end'] = off + s['num_points']
            s['loop_s'] = off
            s['loop_e'] = off + s['num_points'] - 1
            off += s['num_points'] + 46

    def _mk_info(self):
        sub = b'ifil' + struct.pack('<I', 4) + struct.pack('<HH', 2, 4)
        sub += self._schunk(b'isng', 'EMU8000')
        sub += self._schunk(b'INAM', self.name)
        sub += self._schunk(b'ISFT', 'SF2 Creator Pro v2.0')
        return b'LIST' + struct.pack('<I', len(sub) + 4) + b'INFO' + sub

    def _mk_sdta(self):
        smpl = b''
        for s in self.samples:
            smpl += s['pcm']
            smpl += b'\x00' * 92
        sc = b'smpl' + struct.pack('<I', len(smpl)) + smpl
        if len(smpl) % 2:
            sc += b'\x00'
        return b'LIST' + struct.pack('<I', len(sc) + 4) + b'sdta' + sc

    def _mk_pdta(self):
        sub = b''
        sub += self._chunk(b'phdr', self._mk_phdr())
        sub += self._chunk(b'pbag', self._mk_pbag())
        sub += self._chunk(b'pmod', b'\x00' * 10)
        sub += self._chunk(b'pgen', self._mk_pgen())
        sub += self._chunk(b'inst', self._mk_inst())
        sub += self._chunk(b'ibag', self._mk_ibag())
        sub += self._chunk(b'imod', b'\x00' * 10)
        sub += self._chunk(b'igen', self._mk_igen())
        sub += self._chunk(b'shdr', self._mk_shdr())
        return b'LIST' + struct.pack('<I', len(sub) + 4) + b'pdta' + sub

    def _mk_phdr(self):
        d = b''
        bi = 0
        for p in self.presets:
            d += self._fstr(p['name'], 20)
            d += struct.pack('<HHH', p['preset'], p['bank'], bi)
            d += struct.pack('<III', 0, 0, 0)
            bi += 1
        d += self._fstr('EOP', 20)
        d += struct.pack('<HHH', 255, 255, bi)
        d += struct.pack('<III', 0, 0, 0)
        return d

    def _mk_pbag(self):
        d = b''
        gi = 0
        for _ in self.presets:
            d += struct.pack('<HH', gi, 0)
            gi += 1
        d += struct.pack('<HH', gi, 0)
        return d

    def _mk_pgen(self):
        d = b''
        for p in self.presets:
            d += struct.pack('<HH', 41, p['inst_idx'])
        d += struct.pack('<HH', 0, 0)
        return d

    def _mk_inst(self):
        d = b''
        bi = 0
        for inst in self.instruments:
            d += self._fstr(inst['name'], 20)
            d += struct.pack('<H', bi)
            bi += len(inst['zones'])
        d += self._fstr('EOI', 20)
        d += struct.pack('<H', bi)
        return d

    def _mk_ibag(self):
        d = b''
        gi = 0
        for inst in self.instruments:
            for z in inst['zones']:
                d += struct.pack('<HH', gi, 0)
                gi += z.get('num_gens', 1)
        d += struct.pack('<HH', gi, 0)
        return d

    def _encode_gen(self, gen_op, value):
        """Encoda un generador SF2."""
        return struct.pack('<Hh', gen_op, value)

    def _encode_gen_u(self, gen_op, value):
        """Encoda un generador SF2 sin signo."""
        return struct.pack('<HH', gen_op, value)

    def _mk_igen(self):
        d = b''
        for inst in self.instruments:
            for z in inst['zones']:
                gens = self._build_zone_gens(z)
                d += gens
        d += struct.pack('<HH', 0, 0)
        return d

    def _build_zone_gens(self, z):
        """Construye los generadores para una zona del instrumento."""
        d = b''
        
        # Key range
        kr = (z['key_hi'] & 0x7F) << 8 | (z['key_lo'] & 0x7F)
        d += self._encode_gen_u(SF2_GEN_KEY_RANGE, kr)
        
        # Velocity range
        vel_lo = z.get('vel_lo', 0)
        vel_hi = z.get('vel_hi', 127)
        vr = (vel_hi & 0x7F) << 8 | (vel_lo & 0x7F)
        d += self._encode_gen_u(SF2_GEN_VEL_RANGE, vr)
        
        # Attenuation (volumen basado en velocidad)
        attenuation = z.get('attenuation', 0)
        d += self._encode_gen(SF2_GEN_INITIAL_ATTENUATION, attenuation)
        
        # Release volume envelope
        release_tc = z.get('release_tc', timecents(0.3))
        d += self._encode_gen(SF2_GEN_RELEASE_VOL_ENV, release_tc)
        
        # Decay
        decay_tc = z.get('decay_tc', timecents(1.0))
        d += self._encode_gen(SF2_GEN_DECAY_VOL_ENV, decay_tc)
        
        # Sustain (en centibels, 0 = sin atenuación)
        sustain_cb = z.get('sustain_cb', 0)
        d += self._encode_gen(SF2_GEN_SUSTAIN_VOL_ENV, sustain_cb)
        
        # Pan (si stereo, -500 para left, +500 para right; 0 para mono o left de pair)
        pan = z.get('pan', 0)
        d += self._encode_gen(SF2_GEN_PAN, pan)
        
        # Reverb send
        reverb = z.get('reverb', 150)
        d += self._encode_gen(SF2_GEN_REVERB_EFFECTS_SEND, reverb)
        
        # Sample modes (0 = no loop)
        d += self._encode_gen_u(SF2_GEN_SAMPLE_MODES, 0)
        
        # Scale tuning (100 = normal semitone)
        d += self._encode_gen(SF2_GEN_SCALE_TUNING, 100)
        
        # Override root key
        d += self._encode_gen_u(SF2_GEN_OVERRIDING_ROOT_KEY, z['root_key'])
        
        # Sample ID — siempre el último
        d += self._encode_gen_u(SF2_GEN_SAMPLE_ID, z['sample_idx'])
        
        # Si es stereo izquierdo, agregar zona derecha
        if z.get('is_stereo_left', False) and 'right_sample_idx' in z:
            d += self._build_zone_gens_right(z)
        
        return d

    def _build_zone_gens_right(self, z):
        """Construye los generadores para el canal derecho de un par stereo."""
        d = b''
        kr = (z['key_hi'] & 0x7F) << 8 | (z['key_lo'] & 0x7F)
        d += self._encode_gen_u(SF2_GEN_KEY_RANGE, kr)
        
        vel_lo = z.get('vel_lo', 0)
        vel_hi = z.get('vel_hi', 127)
        vr = (vel_hi & 0x7F) << 8 | (vel_lo & 0x7F)
        d += self._encode_gen_u(SF2_GEN_VEL_RANGE, vr)
        
        attenuation = z.get('attenuation', 0)
        d += self._encode_gen(SF2_GEN_INITIAL_ATTENUATION, attenuation)
        
        release_tc = z.get('release_tc', timecents(0.3))
        d += self._encode_gen(SF2_GEN_RELEASE_VOL_ENV, release_tc)
        
        decay_tc = z.get('decay_tc', timecents(1.0))
        d += self._encode_gen(SF2_GEN_DECAY_VOL_ENV, decay_tc)
        
        sustain_cb = z.get('sustain_cb', 0)
        d += self._encode_gen(SF2_GEN_SUSTAIN_VOL_ENV, sustain_cb)
        
        # Pan derecho
        d += self._encode_gen(SF2_GEN_PAN, 500)
        
        reverb = z.get('reverb', 150)
        d += self._encode_gen(SF2_GEN_REVERB_EFFECTS_SEND, reverb)
        
        d += self._encode_gen_u(SF2_GEN_SAMPLE_MODES, 0)
        d += self._encode_gen(SF2_GEN_SCALE_TUNING, 100)
        d += self._encode_gen_u(SF2_GEN_OVERRIDING_ROOT_KEY, z['root_key'])
        d += self._encode_gen_u(SF2_GEN_SAMPLE_ID, z['right_sample_idx'])
        
        return d

    def _mk_shdr(self):
        d = b''
        for s in self.samples:
            d += self._fstr(s['name'], 20)
            d += struct.pack('<IIIII', s['start'], s['end'],
                             s['loop_s'], s['loop_e'], s['sr'])
            d += struct.pack('<Bb', s['root'], 0)
            d += struct.pack('<HH', s['link'], s['sf_type'])
        d += self._fstr('EOS', 20)
        d += struct.pack('<IIIII', 0, 0, 0, 0, 0)
        d += struct.pack('<Bb', 0, 0)
        d += struct.pack('<HH', 0, 0)
        return d


###############################################################################
# LÓGICA DE ZONAS Y SF2
###############################################################################

def calculate_key_zones(midi_notes):
    """Calcula zonas de teclas basadas en notas MIDI."""
    if len(midi_notes) == 1:
        return [(0, 127)]
    zones = []
    sorted_notes = sorted(midi_notes)
    for i, note in enumerate(sorted_notes):
        if i == 0:
            lo = 0
        else:
            lo = (sorted_notes[i - 1] + note) // 2 + 1
        if i == len(sorted_notes) - 1:
            hi = 127
        else:
            hi = (note + sorted_notes[i + 1]) // 2
        zones.append((lo, hi))
    return zones


def calculate_velocity_layers(velocity_samples):
    """
    Dado un dict {velocity: sample_data}, calcula rangos de velocidad.
    Retorna lista de (vel_lo, vel_hi, velocity, sample_data).
    """
    velocities = sorted(velocity_samples.keys())
    result = []
    for i, vel in enumerate(velocities):
        if i == 0:
            lo = 1
        else:
            prev_vel = velocities[i - 1]
            lo = (prev_vel + vel) // 2 + 1
        if i == len(velocities) - 1:
            hi = 127
        else:
            next_vel = velocities[i + 1]
            hi = (vel + next_vel) // 2
        result.append((lo, hi, vel, velocity_samples[vel]))
    return result


def process_samples_to_sf2(writer, sample_list, instrument_name,
                            do_normalize, do_trim,
                            release_ms, reverb_amount,
                            fade_in_ms=3):
    """
    Procesa una lista de samples y los añade al writer SF2.
    Soporta velocidades múltiples por nota.
    
    sample_list: lista de (name, audio_2d, sr, midi_note, velocity, num_channels)
    """
    if not sample_list:
        return []
    
    # Agrupar por nota MIDI -> {midi: {velocity: (name, audio, sr, num_channels)}}
    notes_dict = defaultdict(dict)
    for name, audio, sr, midi_note, velocity, num_channels in sample_list:
        if velocity not in notes_dict[midi_note]:
            notes_dict[midi_note][velocity] = []
        notes_dict[midi_note][velocity].append((name, audio, sr, num_channels))
    
    # Para cada nota y velocidad, tomar el primer sample
    notes_flat = {}
    for midi_note, vel_dict in notes_dict.items():
        notes_flat[midi_note] = {}
        for vel, samples in vel_dict.items():
            notes_flat[midi_note][vel] = samples[0]  # tomar el primero
    
    # Calcular zonas de teclas
    midi_notes = sorted(notes_flat.keys())
    key_zones = calculate_key_zones(midi_notes)
    key_zone_map = dict(zip(midi_notes, key_zones))
    
    zone_list = []
    
    for midi_note in midi_notes:
        key_lo, key_hi = key_zone_map[midi_note]
        vel_dict = notes_flat[midi_note]
        
        # Calcular capas de velocidad
        vel_layers = calculate_velocity_layers(vel_dict)
        
        for vel_lo, vel_hi, velocity, (name, audio, sr, num_channels) in vel_layers:
            # Procesar audio
            if do_normalize:
                audio = normalize_audio(audio)
            if do_trim:
                audio = trim_silence(audio, sr)
            
            # Aplicar fade-in suave
            if fade_in_ms > 0:
                audio = apply_fade_in(audio, sr, fade_in_ms)
            
            # Aplicar fade-out (release natural)
            if release_ms > 0:
                audio = apply_fade_out(audio, sr, release_ms)
            
            if len(audio) < 10:
                continue
            
            # Calcular atenuación por velocidad (más grave = más silencioso)
            # Escala de 0 (127) a ~120 cb (~12 dB quieter, para vel=1)
            # SF2 attenuation: 0 = max volume, 1440 = silent
            vel_ratio = velocity / 127.0
            # Curva suave
            attenuation = int((1.0 - vel_ratio ** 0.5) * 200)
            
            # Release en timecents
            release_seconds = max(0.05, release_ms / 1000.0)
            release_tc = timecents(release_seconds)
            
            reverb_val = min(1000, max(0, int(reverb_amount * 10)))
            
            sample_name = f"{midi_to_note_name(midi_note)}_{velocity}"
            sample_name = sample_name[:20]
            
            if num_channels >= 2:
                left_channel = np.ascontiguousarray(audio[:, 0])
                right_channel = np.ascontiguousarray(audio[:, 1])
                pcm_left = float_to_pcm16(left_channel)
                pcm_right = float_to_pcm16(right_channel)
                
                left_idx, right_idx = writer.add_sample_stereo(
                    sample_name, pcm_left, pcm_right, sr, root_key=midi_note
                )
                
                # Zona izquierda con referencia a derecha
                num_gens = 12 + 12  # 12 gens por canal
                zone_list.append({
                    'key_lo': key_lo,
                    'key_hi': key_hi,
                    'vel_lo': vel_lo,
                    'vel_hi': vel_hi,
                    'root_key': midi_note,
                    'sample_idx': left_idx,
                    'right_sample_idx': right_idx,
                    'is_stereo_left': True,
                    'pan': -500,
                    'attenuation': attenuation,
                    'release_tc': release_tc,
                    'decay_tc': timecents(2.0),
                    'sustain_cb': 0,
                    'reverb': reverb_val,
                    'num_gens': num_gens,
                })
            else:
                mono_data = np.ascontiguousarray(audio[:, 0])
                pcm = float_to_pcm16(mono_data)
                
                sample_idx = writer.add_sample_mono(
                    sample_name, pcm, sr, root_key=midi_note
                )
                
                num_gens = 12
                zone_list.append({
                    'key_lo': key_lo,
                    'key_hi': key_hi,
                    'vel_lo': vel_lo,
                    'vel_hi': vel_hi,
                    'root_key': midi_note,
                    'sample_idx': sample_idx,
                    'is_stereo_left': False,
                    'pan': 0,
                    'attenuation': attenuation,
                    'release_tc': release_tc,
                    'decay_tc': timecents(2.0),
                    'sustain_cb': 0,
                    'reverb': reverb_val,
                    'num_gens': num_gens,
                })
    
    return zone_list, key_zone_map, midi_notes


def count_zones(zone_list):
    """Cuenta el número total de generadores en una lista de zonas."""
    return sum(z.get('num_gens', 12) for z in zone_list)


###############################################################################
# AUDIO EXTENSIONS
###############################################################################

AUDIO_EXTENSIONS = ('.wav', '.wave', '.flac', '.ogg', '.aiff', '.aif')


def is_audio_file(filename):
    return filename.lower().endswith(AUDIO_EXTENSIONS)


def should_skip(basename):
    return basename.startswith('.') or basename.startswith('__') or basename.startswith('~')


###############################################################################
# PROCESADORES PRINCIPALES
###############################################################################

def process_single_instrument_zip(zf, sf2_name, preset_name, do_normalize, do_trim,
                                   release_ms, reverb_amount):
    """Procesa un ZIP con samples en la raíz (un solo instrumento)."""
    sample_list = []
    skipped = []
    errors = []
    stereo_count = 0
    mono_count = 0
    
    for entry in sorted(zf.namelist()):
        if entry.endswith('/'):
            continue
        basename = os.path.basename(entry)
        if should_skip(basename):
            continue
        if not is_audio_file(basename):
            continue
        
        midi_note, velocity = parse_note_name(basename)
        if midi_note is None:
            skipped.append(f"⚠️ `{basename}` — nota no detectada")
            continue
        
        try:
            audio_data = zf.read(entry)
            audio_float, sr, num_channels = read_audio_file(audio_data)
            if audio_float is None:
                errors.append(f"❌ `{basename}` — error de lectura")
                continue
            if len(audio_float) < 100:
                errors.append(f"❌ `{basename}` — audio muy corto")
                continue
            
            if num_channels >= 2:
                stereo_count += 1
            else:
                mono_count += 1
            
            clean_name = os.path.splitext(basename)[0]
            sample_list.append((clean_name, audio_float, sr, midi_note, velocity or 127, num_channels))
        
        except Exception as e:
            errors.append(f"❌ `{basename}` — {str(e)}")
    
    return sample_list, skipped, errors, stereo_count, mono_count


def process_multi_instrument_zip(zf, do_normalize, do_trim, release_ms, reverb_amount):
    """Procesa un ZIP con carpetas (cada carpeta = un instrumento)."""
    # Organizar entries por carpeta
    folder_samples = defaultdict(list)
    skipped = []
    errors = []
    
    for entry in sorted(zf.namelist()):
        if entry.endswith('/'):
            continue
        
        parts = entry.split('/')
        
        # Ignorar archivos en la raíz sin carpeta
        if len(parts) < 2:
            continue
        
        # Carpeta de primer nivel = nombre del instrumento
        instrument_folder = parts[0]
        basename = parts[-1]
        
        if should_skip(basename):
            continue
        if not is_audio_file(basename):
            continue
        
        midi_note, velocity = parse_note_name(basename)
        if midi_note is None:
            skipped.append(f"⚠️ [{instrument_folder}] `{basename}` — nota no detectada")
            continue
        
        try:
            audio_data = zf.read(entry)
            audio_float, sr, num_channels = read_audio_file(audio_data)
            if audio_float is None:
                errors.append(f"❌ [{instrument_folder}] `{basename}` — error de lectura")
                continue
            if len(audio_float) < 100:
                errors.append(f"❌ [{instrument_folder}] `{basename}` — audio muy corto")
                continue
            
            clean_name = os.path.splitext(basename)[0]
            folder_samples[instrument_folder].append(
                (clean_name, audio_float, sr, midi_note, velocity or 127, num_channels)
            )
        
        except Exception as e:
            errors.append(f"❌ [{instrument_folder}] `{basename}` — {str(e)}")
    
    return folder_samples, skipped, errors


###############################################################################
# GRADIO HANDLERS
###############################################################################

def format_size(b):
    if b < 1024:
        return f"{b} B"
    if b < 1_048_576:
        return f"{b / 1024:.1f} KB"
    if b < 1_073_741_824:
        return f"{b / 1_048_576:.1f} MB"
    return f"{b / 1_073_741_824:.1f} GB"


def process_single_zip(file, sf2_name, preset_name, do_normalize, do_trim,
                        release_ms, reverb_amount):
    """Handler para la pestaña de instrumento único."""
    if file is None:
        return None, "❌ Sube un archivo ZIP con los WAVs."
    
    try:
        filepath = file if isinstance(file, str) else file.name
        with open(filepath, 'rb') as f:
            data = f.read()
        
        original_size = len(data)
        
        if not sf2_name or not sf2_name.strip():
            sf2_name = os.path.splitext(os.path.basename(filepath))[0]
        if not preset_name or not preset_name.strip():
            preset_name = sf2_name
        
        try:
            zf = zipfile.ZipFile(io.BytesIO(data))
        except Exception:
            return None, "❌ No se pudo abrir como ZIP."
        
        sample_list, skipped, errors, stereo_count, mono_count = process_single_instrument_zip(
            zf, sf2_name, preset_name, do_normalize, do_trim, release_ms, reverb_amount
        )
        
        if not sample_list:
            msg = build_error_msg(skipped, errors)
            return None, msg
        
        writer = SF2Writer(sf2_name)
        
        result = process_samples_to_sf2(
            writer, sample_list, preset_name,
            do_normalize, do_trim, release_ms, reverb_amount
        )
        
        if not result:
            return None, "❌ No se pudieron procesar los samples."
        
        zone_list, key_zone_map, midi_notes = result
        
        if not zone_list:
            return None, "❌ Ninguna zona válida generada."
        
        writer.add_instrument(preset_name[:20], zone_list)
        writer.add_preset(preset_name[:20], 0, 0, 0)
        
        sf2_bytes = writer.build()
        
        out_name = (sf2_name.replace(' ', '_') or 'output') + '.sf2'
        tmp = tempfile.mkdtemp()
        out_path = os.path.join(tmp, out_name)
        with open(out_path, 'wb') as f:
            f.write(sf2_bytes)
        
        info = build_success_info_single(
            out_name, original_size, sf2_bytes,
            sample_list, stereo_count, mono_count,
            zone_list, key_zone_map, midi_notes,
            skipped, errors, release_ms
        )
        
        return out_path, info
    
    except Exception as e:
        tb = traceback.format_exc()
        return None, f"❌ **Error inesperado:** {str(e)}\n\n```\n{tb}\n```"


def process_multi_zip(file, sf2_name, do_normalize, do_trim,
                       release_ms, reverb_amount):
    """Handler para la pestaña de múltiples instrumentos."""
    if file is None:
        return None, "❌ Sube un archivo ZIP con carpetas de instrumentos."
    
    try:
        filepath = file if isinstance(file, str) else file.name
        with open(filepath, 'rb') as f:
            data = f.read()
        
        original_size = len(data)
        
        if not sf2_name or not sf2_name.strip():
            sf2_name = os.path.splitext(os.path.basename(filepath))[0]
        
        try:
            zf = zipfile.ZipFile(io.BytesIO(data))
        except Exception:
            return None, "❌ No se pudo abrir como ZIP."
        
        folder_samples, skipped, errors = process_multi_instrument_zip(
            zf, do_normalize, do_trim, release_ms, reverb_amount
        )
        
        if not folder_samples:
            msg = "❌ **No se encontraron carpetas con samples válidos.**\n\n"
            msg += "Asegúrate de que el ZIP tenga esta estructura:\n```\nMiSoundFont.zip\n├── Piano/\n│   ├── C3.wav\n│   ├── F3.wav\n│   └── C4.wav\n├── Strings/\n│   ├── C3.wav\n│   └── G3.wav\n└── Bass/\n    ├── E1.wav\n    └── A1.wav\n```\n"
            if skipped:
                msg += f"\n**Archivos ignorados:** {len(skipped)}\n"
                for s in skipped[:10]:
                    msg += f"- {s}\n"
            return None, msg
        
        writer = SF2Writer(sf2_name)
        instruments_info = []
        total_stereo = 0
        total_mono = 0
        
        for preset_num, (instrument_name, sample_list) in enumerate(sorted(folder_samples.items())):
            result = process_samples_to_sf2(
                writer, sample_list, instrument_name,
                do_normalize, do_trim, release_ms, reverb_amount
            )
            
            if not result:
                errors.append(f"❌ [{instrument_name}] — no se pudo procesar")
                continue
            
            zone_list, key_zone_map, midi_notes = result
            
            if not zone_list:
                errors.append(f"❌ [{instrument_name}] — ninguna zona válida")
                continue
            
            inst_idx = writer.add_instrument(instrument_name[:20], zone_list)
            writer.add_preset(instrument_name[:20], preset_num, 0, inst_idx)
            
            stereo = sum(1 for s in sample_list if s[5] >= 2)
            mono = sum(1 for s in sample_list if s[5] < 2)
            total_stereo += stereo
            total_mono += mono
            
            instruments_info.append({
                'name': instrument_name,
                'preset': preset_num,
                'sample_count': len(set((s[3], s[4]) for s in sample_list)),
                'note_count': len(midi_notes),
                'stereo': stereo,
                'mono': mono,
                'midi_notes': midi_notes,
                'key_zone_map': key_zone_map,
            })
        
        if not instruments_info:
            return None, "❌ No se pudo crear ningún instrumento válido.\n\n" + "\n".join(errors[:20])
        
        sf2_bytes = writer.build()
        
        out_name = (sf2_name.replace(' ', '_') or 'output') + '.sf2'
        tmp = tempfile.mkdtemp()
        out_path = os.path.join(tmp, out_name)
        with open(out_path, 'wb') as f:
            f.write(sf2_bytes)
        
        info = build_success_info_multi(
            out_name, original_size, sf2_bytes,
            instruments_info, total_stereo, total_mono,
            skipped, errors, release_ms
        )
        
        return out_path, info
    
    except Exception as e:
        tb = traceback.format_exc()
        return None, f"❌ **Error inesperado:** {str(e)}\n\n```\n{tb}\n```"


###############################################################################
# INFO BUILDERS
###############################################################################

def build_error_msg(skipped, errors):
    msg = "❌ **No se encontraron samples válidos.**\n\n"
    msg += "Asegúrate de que los WAVs tengan la nota en el nombre:\n"
    msg += "`C3.wav`, `F#4.wav`, `Piano_A3_127.wav`, `060.wav`, etc.\n\n"
    if skipped:
        msg += f"**Archivos sin nota detectada ({len(skipped)}):**\n"
        for s in skipped[:15]:
            msg += f"- {s}\n"
        msg += "\n"
    if errors:
        msg += f"**Errores ({len(errors)}):**\n"
        for e in errors[:15]:
            msg += f"- {e}\n"
    return msg


def build_success_info_single(out_name, original_size, sf2_bytes,
                               sample_list, stereo_count, mono_count,
                               zone_list, key_zone_map, midi_notes,
                               skipped, errors, release_ms):
    # Contar capas de velocidad únicas
    vel_layers = defaultdict(set)
    for name, _, sr, midi, vel, nch in sample_list:
        vel_layers[midi].add(vel)
    max_vel_layers = max(len(v) for v in vel_layers.values()) if vel_layers else 1
    
    info = f"""✅ **¡SF2 creado exitosamente!**

---

### 📊 Estadísticas

| Parámetro | Valor |
|-----------|-------|
| 📁 ZIP entrada | {format_size(original_size)} |
| 💾 SF2 salida | {format_size(len(sf2_bytes))} |
| 🎵 Total samples | {len(sample_list)} |
| 🔊 Stereo | {stereo_count} |
| 🔈 Mono | {mono_count} |
| 🎹 Notas cubiertas | {len(midi_notes)} |
| 🎚️ Máx. capas velocidad | {max_vel_layers} |
| 🔔 Release | {release_ms} ms |

---

### 🎹 Mapa del teclado

| Nota | MIDI | Zona (MIDI) | Zona (Notas) | Capas Vel. | Tipo |
|------|------|-------------|--------------|------------|------|
"""
    
    sample_by_note = defaultdict(list)
    for name, _, sr, midi, vel, nch in sample_list:
        sample_by_note[midi].append((vel, nch))
    
    for midi in sorted(midi_notes):
        if midi in key_zone_map:
            lo, hi = key_zone_map[midi]
            lo_name = midi_to_note_name(lo)
            hi_name = midi_to_note_name(hi)
            samples_for_note = sample_by_note[midi]
            vel_count = len(set(v for v, _ in samples_for_note))
            has_stereo = any(nch >= 2 for _, nch in samples_for_note)
            ch_type = "🔊 Stereo" if has_stereo else "🔈 Mono"
            info += f"| **{midi_to_note_name(midi)}** | {midi} | {lo}–{hi} | {lo_name}–{hi_name} | {vel_count} | {ch_type} |\n"
    
    if skipped:
        info += f"\n---\n### ⚠️ Ignorados ({len(skipped)})\n"
        for s in skipped[:10]:
            info += f"- {s}\n"
    
    if errors:
        info += f"\n---\n### ❌ Errores ({len(errors)})\n"
        for e in errors[:10]:
            info += f"- {e}\n"
    
    return info


def build_success_info_multi(out_name, original_size, sf2_bytes,
                              instruments_info, total_stereo, total_mono,
                              skipped, errors, release_ms):
    total_samples = sum(i['sample_count'] for i in instruments_info)
    
    info = f"""✅ **¡SF2 Multi-instrumento creado!**

---

### 📊 Resumen General

| Parámetro | Valor |
|-----------|-------|
| 📁 ZIP entrada | {format_size(original_size)} |
| 💾 SF2 salida | {format_size(len(sf2_bytes))} |
| 🎸 Instrumentos | {len(instruments_info)} |
| 🎵 Total samples | {total_samples} |
| 🔊 Stereo | {total_stereo} |
| 🔈 Mono | {total_mono} |
| 🔔 Release | {release_ms} ms |

---

### 🎸 Instrumentos

| # | Instrumento | Preset | Notas | Samples | S/M |
|---|-------------|--------|-------|---------|-----|
"""
    
    for inst in instruments_info:
        sm = f"{'🔊' if inst['stereo'] > 0 else ''}{'🔈' if inst['mono'] > 0 else ''}"
        info += f"| {inst['preset']} | **{inst['name']}** | P{inst['preset']} | {inst['note_count']} | {inst['sample_count']} | {sm} |\n"
    
    info += "\n---\n"
    
    for inst in instruments_info:
        info += f"\n### 🎵 {inst['name']} (Preset {inst['preset']})\n"
        info += f"| Nota | MIDI | Rango |\n|------|------|-------|\n"
        for midi in sorted(inst['midi_notes'])[:15]:  # Limitar para no saturar
            if midi in inst['key_zone_map']:
                lo, hi = inst['key_zone_map'][midi]
                info += f"| {midi_to_note_name(midi)} | {midi} | {midi_to_note_name(lo)}–{midi_to_note_name(hi)} |\n"
        if len(inst['midi_notes']) > 15:
            info += f"| ... | ... | ({len(inst['midi_notes']) - 15} más) |\n"
    
    if skipped:
        info += f"\n---\n### ⚠️ Ignorados ({len(skipped)})\n"
        for s in skipped[:10]:
            info += f"- {s}\n"
    
    if errors:
        info += f"\n---\n### ❌ Errores ({len(errors)})\n"
        for e in errors[:10]:
            info += f"- {e}\n"
    
    return info


###############################################################################
# INTERFAZ GRADIO
###############################################################################

CSS = """
.gradio-container { font-family: 'Inter', sans-serif; }
.main-header { 
    background: linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%);
    padding: 2rem;
    border-radius: 12px;
    margin-bottom: 1.5rem;
    text-align: center;
    box-shadow: 0 4px 20px rgba(0,0,0,0.3);
}
.main-header h1 { 
    color: #e2e8f0; 
    font-size: 2.2rem; 
    margin: 0;
    text-shadow: 0 2px 4px rgba(0,0,0,0.5);
}
.main-header p { color: #94a3b8; margin: 0.5rem 0 0 0; font-size: 1rem; }
.badge {
    display: inline-block;
    padding: 0.25rem 0.75rem;
    border-radius: 20px;
    font-size: 0.8rem;
    margin: 0.25rem;
    font-weight: 600;
}
.badge-blue { background: #1e3a5f; color: #60a5fa; }
.badge-green { background: #1a3a2a; color: #4ade80; }
.badge-purple { background: #2d1b4e; color: #c084fc; }
"""

with gr.Blocks(
    title="SF2 Creator Pro",
    theme=gr.themes.Soft(
        primary_hue="blue",
        secondary_hue="violet",
        neutral_hue="slate",
    ),
    css=CSS,
) as demo:

    gr.HTML("""
    <div class="main-header">
        <h1>🎹 SF2 SoundFont Creator Pro</h1>
        <p>Convierte colecciones de WAV en SoundFonts SF2 profesionales</p>
        <div style="margin-top:1rem;">
            <span class="badge badge-blue">🔊 Stereo Nativo</span>
            <span class="badge badge-green">🎚️ Capas de Velocidad</span>
            <span class="badge badge-purple">🎸 Multi-Instrumento</span>
            <span class="badge badge-blue">🔔 Release Natural</span>
            <span class="badge badge-green">📀 Sin Compresión</span>
        </div>
    </div>
    """)

    with gr.Tabs():
        
        # ══════════════════════════════════════════════════════════════════════
        # TAB 1: INSTRUMENTO ÚNICO
        # ══════════════════════════════════════════════════════════════════════
        with gr.TabItem("🎵 Un Instrumento", id="single"):
            with gr.Row():
                with gr.Column(scale=1, min_width=340):
                    gr.Markdown("## 📤 Configuración")
                    
                    s_input_file = gr.File(
                        label="ZIP con WAVs",
                        file_types=[".zip"],
                        type="filepath",
                    )
                    
                    with gr.Row():
                        s_sf2_name = gr.Textbox(
                            label="Nombre del SoundFont",
                            placeholder="Mi Piano",
                            value="MySoundFont",
                        )
                        s_preset_name = gr.Textbox(
                            label="Nombre del Preset",
                            placeholder="Piano Acústico",
                            value="Preset 1",
                        )
                    
                    gr.Markdown("### ⚙️ Procesamiento de Audio")
                    
                    with gr.Row():
                        s_do_normalize = gr.Checkbox(
                            label="🔊 Normalizar",
                            value=True,
                            info="Normaliza el volumen al pico",
                        )
                        s_do_trim = gr.Checkbox(
                            label="✂️ Recortar silencio",
                            value=True,
                            info="Elimina silencio al inicio/final",
                        )
                    
                    gr.Markdown("### 🔔 Envelope (ADSR)")
                    
                    s_release_ms = gr.Slider(
                        minimum=50,
                        maximum=5000,
                        value=500,
                        step=50,
                        label="Release (ms)",
                        info="Duración del fade-out al soltar la tecla",
                    )
                    
                    s_reverb = gr.Slider(
                        minimum=0,
                        maximum=100,
                        value=15,
                        step=5,
                        label="Reverb Send (%)",
                        info="Cantidad de reverb incorporada en el SF2",
                    )
                    
                    s_convert_btn = gr.Button(
                        "🎵 Crear SF2",
                        variant="primary",
                        size="lg",
                    )
                    
                    with gr.Accordion("📝 Formatos de nombre soportados", open=False):
                        gr.Markdown("""
```
C3.wav                     → Do3 (MIDI 48)
F#4.wav                    → Fa#4 (MIDI 66)  
Ab3.wav                    → Lab3 (bemol)
Bb2.wav                    → Sib2
Piano_G4.wav               → Sol4
Piano_C3_127.wav           → Do3, vel=127
Piano_C3_64.wav            → Do3, vel=64
Nylon+Steel_E4_127.wav     → Mi4, vel=127
Guitar_F#3_64.wav          → Fa#3, vel=64
060.wav                    → MIDI 60
```
**Capas de velocidad:** pon múltiples archivos de la misma nota con diferentes velocidades:
```
Piano_C3_32.wav   → Do3 suave
Piano_C3_64.wav   → Do3 medio
Piano_C3_127.wav  → Do3 fuerte
```
                        """)
                
                with gr.Column(scale=1):
                    gr.Markdown("## 📥 Resultado")
                    s_output_file = gr.File(label="Archivo SF2 generado")
                    s_output_info = gr.Markdown("*Sube un ZIP para comenzar...*")
            
            s_convert_btn.click(
                fn=process_single_zip,
                inputs=[
                    s_input_file, s_sf2_name, s_preset_name,
                    s_do_normalize, s_do_trim,
                    s_release_ms, s_reverb,
                ],
                outputs=[s_output_file, s_output_info],
            )
        
        # ══════════════════════════════════════════════════════════════════════
        # TAB 2: MULTI-INSTRUMENTO
        # ══════════════════════════════════════════════════════════════════════
        with gr.TabItem("🎸 Multi-Instrumento", id="multi"):
            with gr.Row():
                with gr.Column(scale=1, min_width=340):
                    gr.Markdown("## 📤 Configuración Multi-Instrumento")
                    
                    m_input_file = gr.File(
                        label="ZIP con carpetas de instrumentos",
                        file_types=[".zip"],
                        type="filepath",
                    )
                    
                    gr.Markdown("""
                    **📁 Estructura requerida:**
                    ```
                    MiSoundFont.zip
                    ├── Piano/
                    │   ├── C2.wav
                    │   ├── C2_64.wav   ← vel layer
                    │   ├── F2.wav
                    │   └── C3.wav
                    ├── Strings/
                    │   ├── C3.wav
                    │   └── G3.wav
                    └── Bass/
                        ├── E1.wav
                        └── A1.wav
                    ```
                    Cada carpeta = un instrumento/preset.
                    El nombre de la carpeta = nombre del instrumento.
                    """)
                    
                    m_sf2_name = gr.Textbox(
                        label="Nombre del SoundFont",
                        placeholder="Mi Orquesta",
                        value="MySoundFont",
                    )
                    
                    gr.Markdown("### ⚙️ Procesamiento de Audio")
                    
                    with gr.Row():
                        m_do_normalize = gr.Checkbox(
                            label="🔊 Normalizar",
                            value=True,
                        )
                        m_do_trim = gr.Checkbox(
                            label="✂️ Recortar silencio",
                            value=True,
                        )
                    
                    gr.Markdown("### 🔔 Envelope")
                    
                    m_release_ms = gr.Slider(
                        minimum=50,
                        maximum=5000,
                        value=500,
                        step=50,
                        label="Release (ms)",
                        info="Release aplicado a todos los instrumentos",
                    )
                    
                    m_reverb = gr.Slider(
                        minimum=0,
                        maximum=100,
                        value=15,
                        step=5,
                        label="Reverb Send (%)",
                    )
                    
                    m_convert_btn = gr.Button(
                        "🎸 Crear SF2 Multi-Instrumento",
                        variant="primary",
                        size="lg",
                    )
                
                with gr.Column(scale=1):
                    gr.Markdown("## 📥 Resultado")
                    m_output_file = gr.File(label="Archivo SF2 multi-instrumento")
                    m_output_info = gr.Markdown("*Sube un ZIP con carpetas para comenzar...*")
            
            m_convert_btn.click(
                fn=process_multi_zip,
                inputs=[
                    m_input_file, m_sf2_name,
                    m_do_normalize, m_do_trim,
                    m_release_ms, m_reverb,
                ],
                outputs=[m_output_file, m_output_info],
            )
        
        # ══════════════════════════════════════════════════════════════════════
        # TAB 3: DOCUMENTACIÓN
        # ══════════════════════════════════════════════════════════════════════
        with gr.TabItem("📚 Guía de Uso", id="docs"):
            gr.Markdown("""
## 🎹 SF2 Creator Pro — Guía Completa

### ¿Qué es un SoundFont SF2?

Un archivo SF2 es una colección de samples de audio organizados para ser reproducidos por un sintetizador. Cada sample se asigna a una o más notas del teclado MIDI, y el sintetizador ajusta el pitch automáticamente para las notas intermedias.

---

### 🎵 Pestaña: Un Instrumento

Ideal para crear un SF2 con un solo instrumento (piano, guitarra, etc.).

**Flujo de trabajo:**
1. Reúne tus WAVs grabados/sampleados
2. Nómbralos con la nota que representan (ver formatos)
3. Comprímelos en un ZIP
4. Sube el ZIP y configura las opciones
5. Descarga tu SF2

**Capas de velocidad:** Para tener samples diferentes según la fuerza de pulsación:
```
Piano_C4_32.wav   → suave (vel 1-48)
Piano_C4_64.wav   → medio (vel 49-96)  
Piano_C4_127.wav  → fuerte (vel 97-127)
```

---

### 🎸 Pestaña: Multi-Instrumento

Crea un SF2 con múltiples instrumentos en un solo archivo.

**Estructura del ZIP:**
```
MiOrquesta.zip
├── 00_Grand_Piano/
│   ├── C1.wav, C2.wav, C3.wav, C4.wav, C5.wav
│   ├── C2_64.wav  ← capa de velocidad
│   └── C2_32.wav  ← capa de velocidad
├── 01_Strings/
│   ├── C2.wav, G2.wav, D3.wav
├── 02_Brass/
│   ├── C3.wav, F3.wav
└── 03_Bass/
    ├── E1.wav, A1.wav, D2.wav
```

Los nombres de carpetas se convierten en nombres de presets.
El prefijo numérico (`00_`, `01_`) controla el orden.

---

### 🔔 Envelope (ADSR)

| Parámetro | Descripción | Recomendado |
|-----------|-------------|-------------|
| **Release** | Cuánto tarda en silenciarse al soltar la tecla | 300-800ms piano, 1000-3000ms strings |
| **Reverb Send** | Reverb incorporado en el SF2 | 10-20% para uso general |

---

### 📝 Formatos de nombre de archivo

| Formato | Ejemplo | Resultado |
|---------|---------|-----------|
| Nota simple | `C4.wav` | MIDI 60, vel 127 |
| Con sostenido | `F#3.wav` | MIDI 54, vel 127 |
| Con bemol | `Bb2.wav` | MIDI 46, vel 127 |
| Con instrumento | `Piano_A3.wav` | MIDI 57, vel 127 |
| Con velocidad | `Piano_C3_64.wav` | MIDI 48, vel 64 |
| Vel. compleja | `Nylon+Steel_E4_127.wav` | MIDI 64, vel 127 |
| MIDI directo | `060.wav` | MIDI 60, vel 127 |

---

### 🎼 Distribución automática del teclado

Si subes: `C3`, `F3`, `A#3`, `D#4`, `G4`, `C5`

```
C3  (48) → teclas 0–50    (graves + hasta D#3)
F3  (53) → teclas 51–55   (E3 hasta G#3)
A#3 (58) → teclas 56–60   (A3 hasta C4)
D#4 (63) → teclas 61–65   (C#4 hasta F4)
G4  (67) → teclas 66–73   (F#4 hasta B4)
C5  (72) → teclas 74–127  (C5 hasta lo más agudo)
```

---

### 🔧 Compatibilidad

El SF2 generado es compatible con:
- **FluidSynth** (Linux, multiplataforma)
- **Polyphone** (editor SF2)
- **MuseScore** (notación)
- **LMMS** (DAW gratuito)
- **Reason, Cubase, FL Studio, Ableton** (con plugins SF2)
- **Soundblaster** y hardware compatible con SF2
- **Sitios web** que usen WebAudio + sf2-player

---

### 💡 Consejos para mejores resultados

1. **Graba cada muestra en su nota natural** — el pitch shifting degrada la calidad
2. **Más muestras = mejor calidad** — para piano: cada 3-4 semitonos es ideal
3. **Para instrumentos con sustain** (cuerdas, pad): release alto (2000-5000ms)
4. **Para instrumentos percusivos** (piano, marimba): release bajo (200-600ms)
5. **Normaliza antes de exportar** — muestras balanceadas entre capas de velocidad
6. **WAV 24-bit 44.1kHz o 48kHz** — el SF2 usa 16-bit internamente
7. **Stereo** → más realismo pero archivo más grande; **Mono** → más eficiente
            """)

    gr.HTML("""
    <div style="text-align:center; margin-top:2rem; padding:1rem; 
                border-top: 1px solid #334155; color:#64748b; font-size:0.85rem;">
        <strong>SF2 Creator Pro v2.0</strong> — Compatible con FluidSynth, Polyphone, MuseScore, LMMS y más
    </div>
    """)


if __name__ == "__main__":
    demo.launch()