/* p1.js Piano music player.
There is only 1 function: p1
You call it without parenthesis.

EXAMPLE, PLAY JINGLE BELLS:
p1`c-c-c---|c-c-c---|c-f-Y--a|c-------|d-d-d--d|d-c-c-cc|f-f-d-a-|Y---f---`

TO STOP:
p1``

WITH BASS TRACK:
p1`
|V-Y-c-V-|d---c-a-|
|M-------|R-------|
`

Bass track can be shorter and will repeat.

WITH CUSTOM TEMPO (in milliseconds per note):
p1`70
V-Y-c-V-d---c-a-
M-------R-------`

WITH NOTES HELD DOWN LESS LONG = 30 (0 to 100, default is 50):
p1`70.30
V-Y-c-V-d---c-a-
M-------R-------`

Vertical bars are ingored and don't do anything.
Dashes make the note held longer.
Spaces are silent space.

Supports 52 notes (4 octaves)
How to convert from piano notes to p1 letters:
|Low C      |Tenor C    |Middle C   |Treble C   |High C
C#D#EF#G#A#BC#D#EF#G#A#BC#D#EF#G#A#BC#D#EF#G#A#BC#D#
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
C Major scale: (if you don't want sharp notes then only use these letters)
A C EF H J LM O QR T V XY a cd f h jk m op r t vw y

To save space and not have to double the length of your song just for a few notes that of off beat:
Use a number 0 to 9 to play a note a half beat later that where it stands. 5 is the same note again. 6 is 1 pitch higher, etc.
To play the same note again twice, a beat later and also 1.5 beats later, add an = after it.
*/
!function() {
	var buffers = {},
		contexts = [...Array(12).keys()].map(_=>new AudioContext),
		tracks,
		trackLen,
		interval,
		unlocked,
		noteI,
		vv,pp,ch,
		// Modulation. Generates a sample of a sinusoidal signal with a specific frequency and amplitude.
		b = (note, add) => Math.sin(note*6.28 + add),
		// Instrument synthesis.
		pianoify = (note) => b(note, b(note,0)**2 + b(note,.25)*.75 + b(note,.5)*.1),
		guitarify = (P) => {
            rr = 0
            return vv.length <= 1 + ~~P
            ? (vv.push(2*Math.random() - 1), vv[vv.length - 1])
            : (vv[pp] = .5 * (
              vv[pp >= vv.length - 1 ? 0 : pp + 1] + vv[pp]
              ),
              pp >= ~~P && (
                pp < 1 + ~~P 
                ? ch % 100 >= ~~(100 * (P - ~~P)) && (rr = 1, vv[pp+1] = .5 * (vv[0] + vv[pp + 1]), ch++)
                : rr = 1
              ),
              pp = rr ? 0 : pp + 1,
              vv[pp]
            )
		}
	
	var makeNote = (piano, note, seconds, sampleRate, later) => {
		console.log("makeNote = ()", note, seconds, sampleRate, later)
		var key = ''+piano+note+seconds+later
		var buffer = buffers[key]
		if(note>=0 && !buffer) {
			
			// Calculate frequency/pitch. "Low C" is 65.406
			note = 65.406 * 1.06 ** note / sampleRate
			
			var attack = 99
			var attack2 = attack+.2
			var len = sampleRate * seconds | 0,
				sampleRest = len*4 - attack,
				bufferArray
			buffer = buffers[key] = contexts[0].createBuffer(1, len, sampleRate)
			buffer.later = later
			bufferArray = buffer.getChannelData(0)
			
			vv = []
			pp = ch = 0
			
			// Fill the samples array
			var pow = piano ? ((Math.log(1e4 * note) / 2) ** 2) : 1
			var note1 = 1/note
			var end = len
			var start = end-800
			for(var i=0;i<end;i++) {
				bufferArray[i] =
					// The first 88 samples represent the note's attack
					(i < attack ?
						i / attack2
						// The other samples represent the rest of the note
						: (1 - (i - attack2) / sampleRest) ** pow
					) * (piano ? pianoify(i*note) : guitarify(note1)/4)
			}
			var dist = end-start
			for(var i=start; i<end; i++) {
				bufferArray[i] *= 1-(i-start)/dist
			}
			
			// Safari hack: Play every audioContext then stop them immediately to "unlock" them on ios.
			if(!unlocked) {
				contexts.map(context => playBuffer(buffer, context, unlocked=1))
			}
		}
		return buffer
	}
	
	var playBuffer = (buffer, context, stop, later) => {
		var source = context.createBufferSource()
		source.buffer = buffer
		source.connect(context.destination)
		var f = ()=>source.start()
		if(later>0) {
			setTimeout(f, later)
		} else {
			f()
			if(later<0)
				setTimeout(() => playBuffer(buffer, context), -later)
		}
		stop && source.stop()
	}
	
	p1 = (params) => {
		var tempo = 125, noteLen = .5, custom, noteOld, bufferOld, piano=-1
		tracks = params[trackLen = 0].replace(/[\!\|]/g,'').split('\n').map(track =>
			track>0 ?
				(
					custom = 1,
					track = track.split('.'),
					tempo = track[0],
					noteLen = track[1]/100 || noteLen
				)
			:
				(piano++, track.split('').map((letter, i, letters) => {
					var duration = 1,
						note = letter.charCodeAt(0)
					note -= letter>0 ? 53-noteOld : (note>90 ? 71 : 65)
					while(track[i+duration]=='-' || track[i+duration]>0) {
						duration++
					}
					if(trackLen<i)trackLen=i+1
					if(note>0)noteOld = note
					return makeNote(1,letter=='='?noteOld:note, duration*noteLen/4*tempo/125, contexts[0].sampleRate, letter>0?tempo/2: (letter=='='||letters[i+1]==':'?-tempo/2:0))
				}))
		)
		if(custom)tracks.shift()
		//alert(contexts[0].sampleRate)
		
		noteI = 0
		clearInterval(interval)
		interval = setInterval(j => {
			tracks.map((track,trackI) => {
				if(track[j = noteI % track.length]) {
					playBuffer(track[j], contexts[trackI*3+noteI%3], 0, track[j].later)
				}
			})
			noteI++
			noteI %= trackLen
		}, tempo)
	}
}()