import musiclib, std/[math, sugar]

# Number of times to sample each second
const bitrate = 44100

func osc_piano*(f, t: float): float =
    ## Returns the intensity of a tone of frequency f sampled at time t
    ## t starts at 0 (note start)
    # https://dsp.stackexchange.com/questions/46598/mathematical-equation-for-the-sound-wave-that-a-piano-makes
    # https://youtu.be/ogFAHvYatWs?t=254
    # return int(2**13*(1+square(t, 440*2**(math.floor(5*t)/12))))
    # Y = sum([math.sin(2 * i * math.pi * t * f) * math.exp(-0.0004 * 2 * math.pi * t * f) / 2**i for i in range(1, 4)])
    # Y += Y * Y * Y
    # Y *= 1 + 16 * t * math.exp(-6 * t)
    let w = 2 * PI * f
    var Y = 0.6 * math.sin(w * t) * math.exp(-0.001 * w * t)
    Y += 0.2 * math.sin(2 * w * t) * math.exp(-0.001 * w * t)
    Y += 0.05 * math.sin(3 * w * t) * math.exp(-0.001 * w * t)
    Y += Y * Y * Y
    Y *= 1 + 16 * t * math.exp(-6 * t)
    Y

func osc_pulse*(f,t:float):float =
    let width = (1.0 / f) / 2
    let phase: float = t mod (width * 2)
    if phase < width: 1.0 else: -1.0

func freq*(octave, step: float): float =
    ## Returns the frequency of a note
    55 * pow(2, (octave + step / 12 - 1))

var osc: OscFn = (f, t: float) => 0.0

proc p*(len, octave, step, vol: float = 1): Note =
    ## Note helper constructor
    (len, freq(octave, step), vol, osc)


#------- song region -------

const GAIN_NORMAL = 0.24

osc = (f, t: float) => osc_piano(f, t) * GAIN_NORMAL

let intro = [
    p(1,3,3),
    p(1,3,7),
    p(1,3,10),
    p(6,4,2),

    p(1,3,1),
    p(1,3,5),
    p(1,3,8),
    p(3,4,0),

    p(1,2,11),
    p(1,3,3),
    p(1,3,6),
    p(3,3,10),

    p(1,2,8),
    p(1,3,0),
    p(1,3,3),
    p(8,3,7),
]

# osc = osc_pulse

let melody = [
    p(1,3,3),
    p(1,3,7),
    p(1,3,10),
    p(1,4,2),
    p(1,4,3),
    p(1,4,7),
    p(2,4,8),

    p(1,3,1),
    p(1,3,5),
    p(1,3,8),
    p(1,4,0),
    p(1,4,1),
    p(1,4,5),
    p(2,4,8),

    p(1,3,3),
    p(1,3,7),
    p(1,3,10),
    p(1,4,2),
    p(1,4,3),
    p(1,4,10),
    p(2,4,3),

    p(1,3,1),
    p(1,3,5),
    p(1,3,8),
    p(1,4,0),
    p(1,4,10),
    p(1,4,8),
    p(2,4,10),


    p(1,3,3),
    p(1,3,7),
    p(1,3,10),
    p(1,4,2),
    p(1,4,3),
    p(1,4,7),
    p(2,4,8),

    p(1,3,1),
    p(1,3,5),
    p(1,3,8),
    p(1,4,0),
    p(1,4,1),
    p(1,4,5),
    p(2,4,1),

    p(1,3,3),
    p(1,3,7),
    p(1,3,10),
    p(1,4,2),
    p(1,4,3),
    p(1,4,10),
    p(1,4,8),
    p(1,4,7),

    p(1,3,1),
    p(1,3,5),
    p(1,3,8),
    p(1,4,0),
    p(1,4,10),
    p(1,4,8),
    p(2,4,10),
]

let melody2 = [
    p(1,0,0),
    p(1,5,10),
    p(1,5,8),
    p(1,5,7),
    p(1,5,8),
    p(3,5,7,2),

    p(1,5,3),
    p(1,4,10),
    p(6,5,1,2),

    p(1/2,5,0,2),
    p(1/2,5,1,2),
    p(3,5,3,2),
    p(1/2,5,10,2),
    p(7/2,5,3,2),

    p(8,0,0),

    p(1,0,0),
    p(1,5,3),
    p(1,5,10),
    p(1,5,10),
    p(4/3,5,10),
    p(4/3,5,8),
    p(4/3,5,7),

    p(1,0,0),
    p(1,5,1),
    p(1,5,8),
    p(1,5,8),
    p(4/3,5,8),
    p(4/3,5,8),
    p(4/3,5,10),

    p(8,0,0),

    p(1,0,0),
    p(5,5,3,2),
    p(2,5,10,2),
]

let melody3 = [
    p(1,0,0),
    p(1,5,10),
    p(1/2,5,8,2/3),
    p(1/2,5,7,2/3),
    p(1/4,5,8,1/2),
    p(1/4,5,7,1/2),
    p(1/4,5,8,1/2),
    p(1/4,5,7,1/2),
    p(1,5,8),
    p(3,5,7,2),

    p(1,5,3),
    p(1,4,10),
    p(1,5,1),
    p(5,5,7,2),

    p(1/2,5,7),
    p(1/2,5,10),
    p(1/4,5,7),
    p(1/4,5,10),
    p(1/4,5,7),
    p(1/4,5,10),
    p(1,6,3),
    p(2,5,3,2),
    p(1/2,6,3),
    p(5/2,5,3,2),

    p(1/2,5,10),
    p(1/2,5,8),
    p(1/2,5,7),
    p(1/2,5,8),
    p(1/2,5,7),
    p(1/2,5,3),
    p(1/2,4,10),
    p(1/2,5,1),
    p(1/2,5,0),
    p(1/2,4,10),
    p(1/2,4,8),
    p(1/2,4,10),
    p(1/2,5,3),
    p(1/2,5,7),
    p(1/2,5,3),
    p(1/2,5,10),

    p(4/3,5,7),
    p(4/3,6,3),
    p(4/3,6,3),
    p(4/3,6,2),
    p(4/3,5,10),
    p(4/3,5,7),

    p(3,5,5),
    p(2,5,7),
    p(2,5,8),
    p(1,6,1),

    p(1,5,3),
    p(1,5,5),
    p(2,5,7),
    p(1,5,3),
    p(1,5,8),
    p(2,5,10),

    p(3/2,6,0),
    p(3/2,6,1),
    p(5,6,3,2),
]

let outro = [
    p(1,3,3),
    p(1,3,7),
    p(1,3,10),
    p(1,4,2),
    p(1,4,3),
    p(1,4,7),
    p(2,4,8),

    p(1,3,1),
    p(1,3,5),
    p(1,3,8),
    p(1,4,0),
    p(1,4,1),
    p(1,4,5),
    p(2,4,8),

    p(1,2,11),
    p(1,3,3),
    p(1,3,6),
    p(1,3,10),
    p(1.5,3,11),
    p(1.5,4,3),
    p(3,4,8),

    p(1.5,2,8),
    p(1.5,3,0),
    p(2,3,3),
    p(16,3,7,2),
]

osc = (f, t: float) => osc_piano(f, t) * GAIN_NORMAL * 1.5

let bass = [
    p(1,1,3),
    p(1,1,10),
    p(1,1,1),
    p(1,1,8),
    p(1,1,3),
    p(1,2,3),
    p(1,1,1),
    p(1,1,10),
]

from std/algorithm import sort

# Process all lists of notes
var music: seq[ProcessedNote] = @[]
music.process(intro, 0, 4)
music.process(melody, 8, 4)
music.process(melody, 24, 4)
music.process(bass, 24)
music.process(bass, 32)
music.process(melody, 40, 4)
music.process(melody2, 40, 4)
music.process(bass, 40)
music.process(bass, 48)
music.process(melody, 56, 4)
music.process(melody3, 56, 4)
music.process(bass, 56)
music.process(bass, 64)
music.process(outro, 72, 4)
music.sortByStart()

# Print out music encoded in s16 to standard output
for i in (0 * bitrate ..< 84 * bitrate):
    let bytes = cast[array[4, uint8]](music.at(i / bitrate))
    doAssert 4 == stdout.writeBytes(bytes, 0, 4)