#include "synth_shed.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

void init_synth_shed() {
    printf("init_synth_shed() - called\n");
}

synth_t* synth_create(const char* name) {
    synth_t* new = (synth_t*) malloc(sizeof(synth_t));
    assert(new);
    if (new != NULL) {
        new->model_name = "TESTNAME";
        new->osc_count = 1;
        new->technolgy = ANALOG;
        new->filter.technology = ANALOG;
        new->filter.type = LPF;
    }
    return new;
}

SYNTH_STATUS synth_set_osc_count(synth_t* synth, int osc_count) {
    assert(synth);
    SYNTH_STATUS status = 0;
    if (osc_count < 0) {
        status = 1;
    } else {
        synth->osc_count = osc_count;
    }
    return status;
}


//SYNTH_STATUS synth_set_filter(synth_t* synth,
//        filter_t* filt);
//
//SYNTH_STATUS synth_set_tech(synth_t* synth,
//        tech_t tech);

const char* tech_to_string(const tech_t* const tech) {
    assert(tech);
    const char* ret = "unknown tech";
    if (*tech == ANALOG) {
        return "ANALOG";
    }
    if (*tech == DIGITAL) {
        return "DIGITAL";
    }
    return ret;
}


const char* filtertype_to_string(const filtertype_t* const filt) {
    assert(filt);
    const char* ret = "unknown filtertype";
    if (*filt == LPF) {
        ret = "LPF";
    }
    if (*filt == HPF) {
        ret = "HPF";
    }
    if (*filt == BPF) {
        ret = "BPF";
    }
    return ret;
}


const char* play_synth(synth_t* synth) {
    assert(synth);
    char ret[9999];
    const char* greet = "Playing synth:";
    const char* model = synth->model_name;

    char osc[4];
    sprintf(osc, "%i", synth->osc_count);

    const char* tech = tech_to_string(&synth->technolgy);
    const char* filt_tech = tech_to_string(&synth->filter.technology);
    const char* filt_type = filtertype_to_string(&synth->filter.type);

    sprintf(ret, "%s\nnamed: %s\nosc: %s\ntech:%s\nfilt:%s / %s\n\n", greet, model, osc, tech, filt_tech, filt_type);
    return strdup(ret);
}