from ..base import LockInAmp
from typing import Callable
from time import time as now
import numpy as np

class DummyLockInAmp(LockInAmp):
    def __init__(self):
        super().__init__()

    def test_connection(self) -> None:
        pass

    # RUN COMMANDS ON THE DEVICE
    def run(self, code, verbose=False):
        pass

    def reset(self, verbose=False):
        pass

    def read_value(self) -> tuple[float, float]:
        """
        Read a single value

        Returns
        -------
        [timestamp, voltage]
        """
        t = now() - self.t0
        v = self.amplitude * np.sin(2 * np.pi * t / self.frequency)
        return t, v

    def query(self, query):
        return "-1"

    def snap(self, what="3,4,5,7"):
        vals = [-1.0 for _ in what.split(",")]
        return vals

    def try_recover_from_communication_error(self, original_error):
        pass

    def check_overloads(self) -> bool | str:
        return False

    def read_value(self, which: str):
        return -1.0

    def reset(self):
        pass

    def test_connection(self):
        pass

    # REFERENCE
    def set_reference(self, reference):
        self.reference = reference


    def set_frequency_Hz(self, frequency_Hz):
        self.frequency = frequency_Hz

    def get_frequency_Hz(self) -> float:
        return self.frequency

    def set_reference_trigger(self, trigger):
        self.reference_trigger = trigger

    def set_sensitivity_volt(self, volt):
        self.sensitivity_volt = volt

    def get_sensitivity_volt(self):
        return self.sensitivity_volt

    def set_time_constant_s(self, dt):
        self.time_constant_s = dt

    def get_time_constant_s(self):
        return self.time_constant_s

    def set_filter_slope(self, slope_db_oct):
        self.filter_slope = slope_db_oct

    def get_filter_slope(self):
        return self.filter_slope

    def get_wait_time_s(self):
        """
        Get the wait time required to reach 99% of the final value.
        See Manual 3-21
        :return:
        """
        return 1.0

    def set_sync_filter(self, sync):
        self.sync_filter = sync

    def get_sync_filter(self):
        return self.sync_filter

    def set_reserve(self, reserve):
        self.reserve = reserve

    def get_reserve(self):
        return self.reserve

    max_length = 16383
    def buffer_setup(self, CH1="R", CH2="Theta", length=None, sample_rate=512):
        if length is None:
            length = self.max_length
        self._buffer_length = length

    def buffer_start_fill(self):
        if self._buffer_length is None: raise RuntimeError(f"Buffer not set up, call buffer_setup() first.")

    def buffer_is_done(self) -> bool:
        return True

    def buffer_get_n_points(self) -> int:
        return self._buffer_length

    def buffer_get_data(self, CH1=True, CH2=True):
        data = []
        if CH1:
            data.append(np.arange(self._buffer_length))
        if CH2:
            data.append(np.arange(self._buffer_length))
        return data

    def auto_gain(self):
        pass

    def __str__(self):
        return "Dummy Lock-In"