import math
from types import SimpleNamespace
import torch
model_module=SimpleNamespace(INSTRUMENTS=(),MOODS=(),ROLES=())

def encode_request(request, rate=16, tail=1.0, velocity_mode='original'):
    if velocity_mode not in ('original', 'disabled'):
        raise ValueError('velocity_mode must be original or disabled')
    tempo = request['tempo_bpm']
    num, den = request['time_signature']
    if not math.isfinite(tempo) or tempo <= 0 or (not math.isfinite(request['bar_origin_beats'])):
        raise ValueError('Invalid tempo/bar origin')
    if type(num) is not int or type(den) is not int or num <= 0 or (den <= 0) or den & den - 1:
        raise ValueError('Invalid time signature')
    notes = request['notes']
    for note in notes:
        if type(note['pitch']) is not int:
            raise ValueError('Pitch must be an integer')
        if 'velocity' in note and (type(note['velocity']) is not int or not 1 <= note['velocity'] <= 127):
            raise ValueError('Sounding velocity must be an integer in 1..127')
    controls = request['controls']
    lo, hi = (controls['cc_min'], controls['cc_max'])
    if type(lo) is not int or type(hi) is not int or (not 0 <= lo <= hi <= 127):
        raise ValueError('CC bounds must be integers in 0..127')
    if controls['instrument'] not in model_module.INSTRUMENTS:
        raise ValueError('Unsupported instrument family')
    if rate not in (16, 48) or not math.isfinite(tail) or tail < 0:
        raise ValueError('Invalid rate/tail')
    for note in notes:
        if not (math.isfinite(note['start']) and math.isfinite(note['end']) and (0 <= note['start'] < note['end']) and (0 <= note['pitch'] <= 127)):
            raise ValueError('Invalid note')
    enabled = velocity_mode != 'disabled' and controls['use_velocity'] and all(('velocity' in n for n in notes)) and (len({n.get('velocity') for n in notes}) > 1)
    note_end = max((n['end'] for n in notes), default=0)
    hard_end = note_end + tail if notes else 0
    length = math.ceil(hard_end * rate)
    features = torch.zeros(length, 25)
    rolls = [torch.zeros(length, 128) for _ in range(3)]
    lead = torch.full((length,), 128, dtype=torch.long)
    onsets = sorted({n['start'] for n in notes})
    representatives = {s: max((n['pitch'] for n in notes if n['start'] == s)) for s in onsets}
    group_index = {s: i for i, s in enumerate(onsets)}
    num, den = request['time_signature']
    bar_length = num * 4 / den
    origin = request['bar_origin_beats']
    cap = lambda x, k: min(max(x, 0), k) / k
    for i in range(length):
        t, end = (i / rate, min((i + 1) / rate, hard_end))
        active = [(j, n) for j, n in enumerate(notes) if n['start'] <= t < n['end']]
        starts = [n for n in notes if t <= n['start'] < end]
        stops = [n for n in notes if t <= n['end'] < end]
        for roll, events in zip(rolls, ([n for _, n in active], starts, stops)):
            for n in events:
                roll[i, n['pitch']] += 1
        f = features[i]
        f[0:3] = torch.tensor([bool(active), bool(starts), bool(stops)])
        if active:
            _, n = max(active, key=lambda item: (item[1]['start'], item[1]['pitch'], -item[0]))
            lead[i] = n['pitch']
            g = group_index[n['start']]
            f[3:10] = torch.tensor([n['velocity'] / 127 if enabled else 0, cap(t - n['start'], 8), cap(n['end'] - t, 8), cap(n['end'] - n['start'], 8), (t - n['start']) / (n['end'] - n['start']), (n['pitch'] - representatives[onsets[g - 1]]) / 12 if g else 0, (representatives[onsets[g + 1]] - n['pitch']) / 12 if g + 1 < len(onsets) else 0])
            pitches = [n['pitch'] for _, n in active]
            f[16:18] = torch.tensor([len(active) / 4, (max(pitches) - min(pitches)) / 24])
        else:
            previous = [n['end'] for n in notes if n['end'] <= t]
            following = [n['start'] for n in notes if n['start'] > t]
            f[10:12] = torch.tensor([cap(t - max(previous), 8) if previous else 0, cap(min(following) - t, 8) if following else 0])
        f[12:16] = torch.tensor([math.sin(2 * math.pi * (t - origin)), math.cos(2 * math.pi * (t - origin)), math.sin(2 * math.pi * (t - origin) / bar_length), math.cos(2 * math.pi * (t - origin) / bar_length)])
        f[18:21] = torch.tensor([cap(t, 16), cap(note_end - t, 16), cap(hard_end - t, 16)])
        if starts:
            f[21] = (min((n['start'] for n in starts)) - t) * rate
            f[23] = cap(sum((n['end'] - n['start'] for n in starts)) / len(starts), 8)
            f[24] = sum((n['velocity'] for n in starts)) / len(starts) / 127 if enabled else 0
        if stops:
            f[22] = (min((n['end'] for n in stops)) - t) * rate
    inputs = dict(lead_pitch=lead[None], pitch_roll=rolls[0][None], onset_roll=rolls[1][None], offset_roll=rolls[2][None], frame_numeric=features[None], mood_id=torch.tensor([model_module.MOODS.index(controls['mood'])]), role_id=torch.tensor([model_module.ROLES.index(controls['track_role'])]), instrument_id=torch.tensor([model_module.INSTRUMENTS.index(controls['instrument'])]), ctrl_numeric=torch.tensor([[lo / 127, hi / 127, request['tempo_bpm'] / 200, num / 8, den / 8, float(enabled)]]), mask=torch.ones(1, length, dtype=torch.bool))
    return (inputs, hard_end)