// HW3
// Tyler Thorne


// pick a physical model "BlowHole", send to left chan (0)
BlowHole physmod => dac.left;

// bring in a mono .wav file from which to play sample
// pass through Envelope to avoid clicks from SndBuf 
// to right chan (1)
SndBuf sampler => Envelope samplerEnv => dac.right;
me.sourceDir() + "/WhatLight.wav" => string _file;
_file => sampler.read;
cherr <= "[score] SndBuf: " <= _file <= IO.newline();
20::ms => samplerEnv.duration;

// write signals to file
dac => WvOut2 out => blackhole;
me.sourceDir() + "/Tunes.wav" => string _capture;
_capture => out.wavFilename;


// ------------------------------------------------------------
// three algorithms which generate numbers in range -1.0 to 1.0
// see 1) logisticMapNotes.ck 2) logisticMapNotesOSC.ck for
// more info
fun float logistic(float x, float r) {
    return r * x * (1.0 - x);
}

// see 1) psuedoRandomNotes.ck 2) psuedoRandomNotesOSC.ck for
// more info
fun float random(float r) {
    if (r > 1.0) {
        1.0 => r;
    }
    // get a random value
    return Math.random2f(-r, r);
}

// see 1) sinNotes.ck 2) sinNotesOSC.ck
fun float sinusoid(float  r) {
    // rate in radians at 1 sec period
    2 * pi => float sinScale;
    // convert to desired rate in radians
    if (r > 0.0) r /=> sinScale;
    // current time in seconds
    now / second => float nowInSeconds;
    // convert to phase angle using rate in radians
    nowInSeconds * sinScale => float currentPhase; 
    // or could be another trig function
    return Math.sin(currentPhase); 
}
// ------------------------------------------------------------


// tick the chosen algorithm to get a new value
fun float algorithm(float state, string type, float r) {
    if (type == "logistic") {
        // choose me to iterate the map and hear logistic map "tune"
        return logistic(state, r);
    } else if (type == "random") {
        // choose me for random "tune"
        return random(r);
    } else if (type == "sinusoid") {
        // choose me for sin function "tune"
        return sinusoid(r);
    } else {
        cherr <= "[score] Unknown algorithm type.\n";
    }
}

// sporkable function that plays physical model notes forever
fun void pLoop(string type, float r) {
    0.1 => float state;
    while (true) {
        // note off in case it's already on
        physmod.stopBlowing(1.0);
        // a short rest
        50::ms => now;							
        algorithm(state, type, r) => state;
        // use state as a frequency   
        440.0 + (state * 220.0)  => float f;  
        // to clarinet
        physmod.freq(f);
        // note on
        physmod.startBlowing(0.6);                    
        // OPTIONAL --------------------------------------
        // add any other Clarinet parameters
        // .reed - reed stiffness [0.0 - 1.0]
        // .noiseGain - noise component gain [0.0 - 1.0]
        // .clear - clear instrument
        // .vibratoFreq - vibrato frequency(Hz)
        // .vibratoGain - vibrato gain [0.0 - 1.0]
        // .pressure - pressure/volume [0.0 - 1.0]
        // .rate - rate of attack (sec)
        100::ms => now;
    }
}

// sporkable function that plays sampler notes forever
fun void sLoop(string type, float r) {
    0.1 => float state;
    while (true) {
        // turn off envelope in case it's already on
        samplerEnv.target(0.0);
        // a short rest 
        50::ms => now;							
        algorithm(state, type, r) => state;
        sampler.length() => dur totalFile;
        // time in file to start playing sample from
        ((state + 1.0) * 0.5) * totalFile * r => dur start;
        // sample duration
        100::ms => dur duration;
        // end time of sample
        start + duration => dur end;
        if (end > totalFile) {
            end - duration => start;
        }
        // start position in file in actual samples
        sampler.pos((start / samp) $ int);
        // ramp up the envelope
        samplerEnv.target(1.0);
        
        // OPTIONAL ----------------------------------------
        // play around with 
        // .rate - (float, READ/WRITE) set/get playback rate 
        //         relative to file's natural speed. Try the
        //         range between [-1, 1] and experiment.
        duration => now;
    }
}


// ------------------------------------------------------------
// prepare the show
Shred pShred;
Shred sShred;

// needed to stop both shreds gracefully
fun void killShreds() {
    pShred.exit();
    sShred.exit();
    me.yield();
    // note off
    physmod.stopBlowing(1.0);
    // turn off envelope
    samplerEnv.target(0.0);		
    10::ms => now;
}


// ------------------------------------------------------------
// start the show, starts with BlowHole and Sample
spork ~pLoop("logistic", 7) @=> pShred; // Saxofony played by logistic map frequencies
spork ~sLoop("sinusoid", 3) @=> sShred; // samples pulled sinusoid	
7::second => now;
killShreds();
.40::second => now;

// solo samples
spork ~pLoop("logistic", 3) @=> pShred; // BlowHole played by logistic map frequencies
spork ~sLoop("logistic", 2) @=> sShred; // samples pulled randomly	
6::second => now;
killShreds();
.1::second => now;

// bring both loops together
spork ~sLoop("sinusoid", .1) @=> sShred;
2::second => now;
killShreds();
0.05::second => now;

// bring both loops together
spork ~sLoop("sinusoid", .7) @=> sShred;
4::second => now;
killShreds();
0.05::second => now;

// bring both loops together
spork ~sLoop("sinusoid", .5) @=> sShred;
7::second => now;
killShreds();
0.05::second => now;

// bring both loops together
spork ~sLoop("sinusoid", .1) @=> sShred;
2::second => now;
killShreds();
0.05::second => now;

spork ~pLoop("logistic", 2) @=> pShred; // BlowHole played by logistic map frequencies
spork ~sLoop("logistic", 2) @=> sShred; // samples pulled randomly	
5::second => now;
killShreds();

// bring both loops together
spork ~pLoop("sinusoid", 4) @=> pShred;
spork ~sLoop("sinusoid", 4) @=> sShred;
4::second => now;
killShreds();
0.05::second => now;

// bring both loops together
spork ~sLoop("sinusoid", .5) @=> sShred;
3::second => now;
killShreds();
0.05::second => now;

spork ~pLoop("logistic", 8) @=> pShred; // BlowHole played by logistic map frequencies
spork ~sLoop("logistic", 8) @=> sShred; // samples pulled randomly	
4::second => now;
killShreds();

// bring both loops together
spork ~sLoop("sinusoid", .1) @=> sShred;
3::second => now;
killShreds();
0.05::second => now;

spork ~pLoop("logistic", 8) @=> pShred; // BlowHole played by logistic map frequencies
spork ~sLoop("logistic", 8) @=> sShred; // samples pulled randomly	
4::second => now;
killShreds();

// bring both loops together
spork ~sLoop("sinusoid", .1) @=> sShred;
1::second => now;
killShreds();
0.05::second => now;


// ------------------------------------------------------------
// finish the show
out.closeFile();

// print message in terminal for sox command
cherr <= "[score] Finished.\n";
cherr <= me.sourceDir() + "/Tunes.wav";