
const fN=document.getElementById("kmitocet");
const aN=document.getElementById("amplituda");
const fM=document.getElementById("kmitocetM")
const aM=document.getElementById("amplitudaM");
const selectTyp=document.getElementById("typModulace");
const vyberPrubeh=document.getElementById("prubehModulacnihoSignalu");
const hloubkaModulace=document.getElementById("Hloubka");
const faze=document.getElementById("Faze");




const FNIN= document.getElementById("fNosInput");
const ANIN= document.getElementById("aNosInput");
const FMIN= document.getElementById("fModInput");
const AMIN= document.getElementById("aModInput");
const HLIN= document.getElementById("HloubkaInput");



const vzorkovaciKmitocet=2048;
let kmitocetN=40;
let kmitocetM=20;
let ampN=1;
let ampM=1;
let hloubkaM=1;
let phase=0;
let cas=2;


let INFN;
let INAN;
let INFM;
let INAM;
let INHL;

let frequencies=[];
let times = [];
let spectrum1=[];
let data5=[];




    fN.addEventListener('input', function handleChange(event) {
    console.log(event.target.value);
    kmitocetN= Number(event.target.value);
    FNIN.value=kmitocetN;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum();


});

fM.addEventListener('input', function handleChange(event) {
    console.log(event.target.value);
    kmitocetM= Number(event.target.value);
    FMIN.value=kmitocetM;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum();

});

aM.addEventListener('input', function handleChange(event) {
    console.log(event.target.value);
    ampM= Number(event.target.value);
    AMIN.value=ampM;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()

});

aN.addEventListener("input",function handleChange(event){


    console.log(event.target.value);
    ampN=Number(event.target.value);
    ANIN.value=ampN;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()



})

hloubkaModulace.addEventListener("input", function handleChange(event){
    console.log(event.target.value);
    hloubkaM=Number(event.target.value);
    HLIN.value=hloubkaM;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()


})



FNIN.addEventListener("input", function handleChange(event){

    INFN=Number(event.target.value);
    fN.value=INFN;
    kmitocetN=INFN;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()




})

FMIN.addEventListener("input", function handleChange(event){

    INFM=Number(event.target.value);
    fM.value=INFM;
    kmitocetM=INFM;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()


})


AMIN.addEventListener("input", function handleChange(event){

    INAM=Number(event.target.value);
    aM.value=INAM;
    ampM=INAM;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()


})

ANIN.addEventListener("input", function handleChange(event){

    INAN=Number(event.target.value);
    aN.value=INAN;
    ampN=INAN;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()



})

HLIN.addEventListener("input", function handleChange(event){

    INHL=Number(event.target.value);
    hloubkaModulace.value=INHL;
    hloubkaM=INHL;
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    fftecko();
    zobrazModuloveSpektrum()


})


let sinusN=[];
let hodnoty =[];

function sinusNosna() {

    sinusN=[];
    hodnoty =[];

    let pocetVzorku = Math.round(cas*vzorkovaciKmitocet);


    for (let i = 0; i < pocetVzorku; i++) {
        const perioda = i /vzorkovaciKmitocet;
        sinusN[i] = ampN * Math.cos(2 * Math.PI * kmitocetN * perioda);
    }


    for (let i = 0; i < sinusN.length; i++) {
        hodnoty.push([i / vzorkovaciKmitocet, sinusN[i]]);
    }
}


function zobrazNosnySignal() {

    sinusNosna();


    const data = [hodnoty];


    const options = {title: "Nosný signál",
        xaxis: {
            title: "Čas (s)",
            max:1,
            autoscale: true
        },
        yaxis: {
            title: "Amplituda",
            autoscale: true
        }

    };

    Flotr.draw(document.getElementById("nosnaGraf"),data,options);

}



let sinusM=[];
let hodnotySinM =[];
function sinus(){

    sinusM=[];
    hodnotySinM =[];

    let pocetVzorku = Math.round(cas*vzorkovaciKmitocet);




    for (let i = 0; i < pocetVzorku; i++) {
        const perioda = i /vzorkovaciKmitocet;
        sinusM[i] = ampM * Math.sin((2 * Math.PI * kmitocetM * perioda +phase));
    }


    for (let i = 0; i < sinusM.length; i++) {
        hodnotySinM.push([i / vzorkovaciKmitocet, sinusM[i]]);
    }
}


let trojuhelnikM=[];
let  hodnotyTrojuhelnik = [];
function trojuhelnik() {

    trojuhelnikM=[];
    hodnotyTrojuhelnik = [];

    const vzorkyZacyklus = vzorkovaciKmitocet / kmitocetM;
    const pulVzorky = vzorkyZacyklus / 2;
    const pocetVzorku = Math.round(vzorkovaciKmitocet * cas);
    const radZaVzorek = 2 * Math.PI / vzorkovaciKmitocet;
    const posunFaze = phase / radZaVzorek;

    for (let i = 0; i < pocetVzorku; i++) {
        const perioda = i / vzorkyZacyklus;
        const vzorkyZaperiodu = (((perioda * vzorkyZacyklus) + posunFaze) % vzorkyZacyklus) - pulVzorky;

        if (vzorkyZaperiodu < 0) {
            trojuhelnikM[i] = ampM * (2 * vzorkyZaperiodu / vzorkyZacyklus + 1);
        } else {
            trojuhelnikM[i] = ampM * (-2 * vzorkyZaperiodu / vzorkyZacyklus + 1);
        }
    }


    for (let i = 0; i < trojuhelnikM.length; i++) {
        hodnotyTrojuhelnik.push([i / vzorkovaciKmitocet, trojuhelnikM[i]]);
    }
}

let obdelnikM=[];
let hodnotyObdelnik = [];
function obdelnik() {

    obdelnikM=[];
    hodnotyObdelnik = [];

    const vzorkyZacyklus = vzorkovaciKmitocet / kmitocetM;
    const pulVzorky = vzorkyZacyklus / 2;
    const pocetVzorku = Math.round(vzorkovaciKmitocet * cas);
    const radZaVzorek = 2 * Math.PI / vzorkovaciKmitocet;
    const posunFaze = phase / radZaVzorek;

    for (let i = 0; i < pocetVzorku; i++) {
        const perioda = i / vzorkyZacyklus;
        const vzorkyZaperiodu = (((perioda * vzorkyZacyklus) + posunFaze) % vzorkyZacyklus) - pulVzorky;

        if (vzorkyZaperiodu < 0) {
            obdelnikM[i] = ampM;
        } else {
            obdelnikM[i] = -ampM;
        }
    }



    for (let i = 0; i < obdelnikM.length; i++) {
        hodnotyObdelnik.push([i / vzorkovaciKmitocet, obdelnikM[i]]);
    }
}





let pilaM = [];
let hodnotyPila = [];


function pila() {

    pilaM = [];
    hodnotyPila = [];

    const vzorkyZacyklus = vzorkovaciKmitocet / kmitocetM;
    const pocetVzorku = Math.round(vzorkovaciKmitocet * cas);
    const radZaVzorek = 2 * Math.PI / vzorkovaciKmitocet;
    const posunFaze = phase / radZaVzorek;

    for (let i = 0; i < pocetVzorku; i++) {
        const perioda = i / vzorkyZacyklus;
        const vzorkyZaperiodu = (((perioda * vzorkyZacyklus) + posunFaze) % vzorkyZacyklus);

        pilaM[i] = ampM * (2 * (vzorkyZaperiodu / vzorkyZacyklus) - 1);
    }


    for (let i = 0; i < pilaM.length; i++) {
        hodnotyPila.push([i / vzorkovaciKmitocet, pilaM[i]]);
    }
}
let selectFaze;

faze.addEventListener("change",function handleChange(event){

    selectFaze=Number(event.target.value)

    if (selectFaze===12){

        phase=0;

    }
    else if (selectFaze===13){

        phase=1/4*Math.PI;

    }
    else if (selectFaze===14){

        phase=1/2*Math.PI;

    }

    else if (selectFaze===15){

        phase=3/4*Math.PI;

    }

    else if (selectFaze===16){

        phase=Math.PI;

    }

    else if (selectFaze===17){

        phase=5/4*Math.PI;

    }

    else if (selectFaze===18){

        phase=3/2*Math.PI;

    }

    else if (selectFaze===19){

        phase=7/4*Math.PI;

    }

    else if (selectFaze===20){

        phase=2*Math.PI;

    }


    fftecko();
    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    zobrazModuloveSpektrum()
})










let Selekt3=4;


vyberPrubeh.addEventListener('change', function handleChange(event) {




    Selekt3 =Number(event.target.value);


    if (Selekt3 === 4) {

        sinus();


    }
    else if (Selekt3 === 5) {

        obdelnik();

    }
    else if (Selekt3 === 6) {


        trojuhelnik();

    }

    else if (Selekt3 === 7) {

        pila();

    }

    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    zobrazModuloveSpektrum()

});

let vystupDsb=[];










let modulovanySignal = [];
let hodnotyDSBFC = [];  // Array to store time-value pairs

function DSBFC() {


    hodnotyDSBFC=[];

    sinus();
    sinusNosna();

    for (let i = 0; i < sinusN.length; i++) {
        modulovanySignal[i] = sinusN[i]+(hloubkaM * sinusM[i]* sinusN[i]/ampN);
        const time = i / vzorkovaciKmitocet;
        hodnotyDSBFC.push([time, modulovanySignal[i]]);
    }

    console.log(hodnotyDSBFC);
}


function DSBSC() {

    hodnotyDSBSC = [];

    sinus();
    sinusNosna();
    modulovanySignal=[];

    for (let i = 0; i < sinusN.length; i++) {
        modulovanySignal[i] = hloubkaM * sinusM[i] * sinusN[i] / ampN;
        const time = i / vzorkovaciKmitocet;
        hodnotyDSBSC.push([time, modulovanySignal[i]]);
    }

    console.log(hodnotyDSBSC); // Print the array of time-value pairs to the console for verification
}


let times2;
let modulovanySignal1=[];

let spectrum2=[];
let hodnotyssbfilter=[];
let zeros=[];
let vysledek=[];
let newSpectrum=[];
let ssbfiltrovane=[];

function ssb() {
    hodnotyssb = [];

    sinus();
    sinusNosna();

    for (let i = 0; i < sinusN.length; i++) {
        modulovanySignal1[i] = sinusN[i] + (hloubkaM * sinusM[i] * sinusN[i] / ampN);
        const time = i / vzorkovaciKmitocet;
        hodnotyssb.push([time, modulovanySignal1[i]]);
    }

    times2=[];

    for (let i = 0; i < hodnotyssb.length; i++) {
        times2.push(hodnotyssb[i][1]);
    }

    console.log(times2); // check

    const fft2 = new FFT(times2.length, vzorkovaciKmitocet);
    fft2.forward(times2);

    frequencies2=[];

    for (let i = 0; i < hodnotyssb.length/2; i++) {
        frequencies2.push(i * vzorkovaciKmitocet / hodnotyssb.length);
    }

    spectrum2 = fft2.spectrum;

    const carrierIndex = Math.round(kmitocetN/ (vzorkovaciKmitocet / times2.length));
    console.log(carrierIndex);


    for (let i = carrierIndex+1; i < spectrum2.length; i++) {
        spectrum2[i] = 0;
    }

    console.log(spectrum2);


    newSpectrum = new Float32Array(spectrum2.length * 2);
    for (let i = 0; i < spectrum2.length; i++) {
        newSpectrum[1 * i] = spectrum2[i];
        newSpectrum[1 * i + 1] = 0;
    }

    console.log(newSpectrum);


     vysledek = fft2.inverse(newSpectrum);

    ssbfiltrovane=[];

    console.log(vysledek);

    for (let i = 0; i < sinusN.length; i++) {
        const time = i / vzorkovaciKmitocet;
        ssbfiltrovane.push([time, vysledek[i]]);
    }



}



function SSBSC() {


}




let  hodnotyModulacni=[];
function zobrazModulacniSignal() {

    sinus();
    obdelnik();
    trojuhelnik();
    pila();


    hodnotyModulacni=[];

    if (Selekt3 === 4){


        hodnotyModulacni=hodnotySinM;

    }

    else if (Selekt3 === 5){


        hodnotyModulacni=hodnotyObdelnik;

    }


    else if (Selekt3 === 6){


        hodnotyModulacni=hodnotyTrojuhelnik;

    }



    else if (Selekt3 === 7){


        hodnotyModulacni=hodnotyPila;

    }


    const data2 = [hodnotyModulacni
    ];

    const options2 = {title: "Modulační signál",
        xaxis: {
            title: "čas (s)",
            max:1,
            autoscale: true
        },
        yaxis: {
            title: "Amplituda",
            autoscale: true
        }

    };

    Flotr.draw(document.getElementById("modulacniGraf"),data2,options2);

}




let Selekt1=1;

selectTyp.addEventListener('change', function handleChange(event) {




    Selekt3 =Number(event.target.value);


    if (Selekt1 === 1) {

    DSBFC;


    }
    else if (Selekt1 === 2) {

    DSBSC();

    }
    else if (Selekt1 === 3) {


    SSB();

    }

    else if (Selekt3 === 40) {

 SSBSC

    }

    zobrazNosnySignal();
    zobrazModulacniSignal();
    zobrazVyslednySignal();
    zobrazModuloveSpektrum()

});








let hodnotyVysledne=[];
function zobrazVyslednySignal() {

    DSBFC();
    DSBSC();
    ssb();
    SSBSC();


    hodnotyVysledne=[];

    if(Selekt1===1){

        hodnotyVysledne=ssbfiltrovane;

    }



    else if(Selekt1===2){

        hodnotyVysledne=vystupDsbSC;

    }



    else  if(Selekt1===3){

        hodnotyVysledne=vystupSsb;
    }

    else if(Selekt1===40){

        hodnotyVysledne=vystupDsbRc;
    }



    const data3 = [hodnotyVysledne];
    const options3 = {title: "Signál po provedení amplitudové modulace",
        xaxis: {
            title: "čas (s)",
            max:2,
            autoscale: true
        },
        yaxis: {
            title: "Amplituda",
            autoscale: true
        }

    };

    console.log(data3)

    Flotr.draw(document.getElementById("VyslednyGraf"), data3, options3);

}



zobrazNosnySignal();
zobrazModulacniSignal();
zobrazVyslednySignal();



let spectrum=[];
function fftecko() {

    DSBFC();
    DSBSC();
    ssb();
    SSBSC();



    hodnotyVysledne=[];

    if(Selekt1===1){

        hodnotyVysledne=ssbfiltrovane;

    }



    else if(Selekt1===2){

        hodnotyVysledne=vystupDsbRc;

    }



    else  if(Selekt1===3){

        hodnotyVysledne=vystupSsb;
    }

    else if(Selekt1===40){

        hodnotyVysledne=vystupDsbRc;
    }


    times=[];

    for (let i = 0; i < hodnotyVysledne.length; i++) {
        times.push(hodnotyVysledne[i][1]);
    }

    console.log(times); // check

    const fft = new DFT(times.length, vzorkovaciKmitocet);
    fft.forward(times);


    spectrum = fft.spectrum;
    spectrum1 =  Array.prototype.slice.call(spectrum);

frequencies=[];

    for (let i = 0; i < hodnotyVysledne.length/2; i++) {
        frequencies.push(i * vzorkovaciKmitocet / hodnotyVysledne.length);
    }

    console.log(frequencies); // check
    console.log(times);

}



function zobrazModuloveSpektrum() {





    data5=[];
    fftecko();

    for (let i = 0; i < frequencies.length; i++) {
        data5.push([frequencies[i], newSpectrum[i]]);
    }

    const options4 = {


        title:"Modulové spektrum výsledného signálu",
        bars: {
            show: true,
            barWidth: 0.2,
        },

        xaxis: {

            min:0,
            max:100,
        },


        yaxis: {
            autoscale:true,
        }

    };

    Flotr.draw(document.getElementById("ModuloveSpektrum"),[data5], options4);

}


zobrazModuloveSpektrum();