import numpy as np
import scipy as sp
from threading import Thread
import time
import queue

import matplotlib.animation as animation
import matplotlib.pyplot as plt

from rtlsdr import RtlSdr

import dsp


class GFSKDemod: 
    def __init__(self, sdr:RtlSdr, baud_rate:int=9600, num_samples:int=512):
        self.sdr = sdr
        self.baud_rate = baud_rate
        self.num_samples = num_samples
        self.fig, self.ax = plt.subplots()

        self.duration = self.num_samples/self.sdr.sample_rate

    # Demodulate an update the sound buffer
    def _demod(self, samples):
        message = dsp.quad_demod(samples)
        message = dsp.lowpass(message, 16E3, self.sdr.sample_rate)
        #message /= np.max(np.abs(message))
        #message = message.astype(np.float32)
        time = len(message)*self.sdr.sample_rate
        t = np.linspace(0,time,len(message))
        return t, message


    # Begin reading and demodulation
    async def start(self):
        plt.ion()
        plt.show()

        async for samples in self.sdr.stream(self.num_samples):
            self.ax.clear()
            t, message = self._demod(samples)

            #num_samples = int(len(message)*self.resample_rate/self.sdr.sample_rate)
            #message = sp.signal.resample(message, num_samples)

            #t = np.linspace(0,1,len(message))*t[:-1]
            #self.ax.plot(t,message)
            #spectrum = np.abs(sp.fft.fftshift(sp.fft.fft(samples)))**2
            #spectrum_db = dsp.db(spectrum)
            #self.ax.plot(spectrum_db)

            self.fig.canvas.draw()
            self.fig.canvas.flush_events()


    def stop(self):
        self.sdr.cancel_read_async()