#!/usr/bin/python3
import shared_simulated_state
import math
import climate_chamber_dummy

VNA_dummy_instance = None


def get_vna_dummy(target_accuracy):
    global VNA_dummy_instance
    if VNA_dummy_instance is None:
        VNA_dummy_instance = VnaDummy(target_accuracy)
    return VNA_dummy_instance


class VnaDummy:
    def __init__(self, target_accuracy):
        self.target_accuracy = target_accuracy

        # store the credentials so that methods can access them

        # Simulated Variables
        self.simulated_traces = [('Trc1', 's11')]
        self.result_format = 'SDAT'
        self.simulated_power = '10.dBm'
        self.simulated_frequency = '10.MHz'
        self.simulated_magnitude = 0.5
        self.simulated_phase = 70
        self.simulated_state = shared_simulated_state.get_simulated_state()
        self.last_simulated_time = self.simulated_state.simulated_time
        self.tau_mag = 25
        self.tau_phase = 35
        self.reference_magnitude = 7  # at reference temp and reference hum
        self.reference_phase = 70  # at reference temp and reference hum
        self.reference_temp = 25
        self.magnitude_slope = 0.2
        self.phase_slope = 0.1
        self.communication_delay = 0.2

    def run_simulation(self):
        self.simulate_magnitude()
        self.simulate_phase()
        self.last_simulated_time = self.simulated_state.simulated_time

    def simulate_magnitude(self):

        target_magnitude = self.reference_magnitude - self.magnitude_slope * \
                           (self.simulated_state.simulated_temperature - self.reference_temp)
        delta_magnitude = target_magnitude - self.simulated_magnitude
        new_time = self.simulated_state.simulated_time
        delta_time = new_time - self.last_simulated_time

        self.simulated_magnitude = self.simulated_magnitude+delta_magnitude*(1-(math.exp(-1.*delta_time/self.tau_mag)))

    def simulate_phase(self):

        target_phase = self.reference_phase + self.phase_slope * \
                       (self.simulated_state.simulated_temperature - self.reference_temp)
        delta_phase = target_phase - self.simulated_phase
        new_time = self.simulated_state.simulated_time
        delta_time = new_time - self.last_simulated_time

        self.simulated_phase = self.simulated_phase + delta_phase*(1 - (math.exp(-1. * delta_time/self.tau_phase)))

    def get_tupple_of_current_traces(self):
        """
        Returns list of tuples containing trace and measured parameter pairs

        :return: list of tuples
        """
        return self.simulated_traces

    def create_new_trace(self, name, parameter):
        self.simulated_traces.append((name, parameter))

    def set_trace_measurements(self, trace, measurement):
        pass

    def get_current_power(self):
        return self.simulated_power

    def set_power(self, power):
        self.simulated_power = power

    def get_current_cw_frequency(self):
        return self.simulated_frequency

    def set_cw_frequency(self, frequency):
        self.simulated_frequency = frequency
        response = 'frequency set'
        return response

    def set_sweep_mode(self, mode):
        return '1'
    
    def get_measurement_string(self, trace, result_format):

        self.simulated_traces = trace
        self.result_format = result_format

        phase_radian = self.simulated_phase / 180. * math.pi
        real_val = self.simulated_magnitude * math.cos(phase_radian)
        imaginary_val = self.simulated_magnitude * math.sin(phase_radian)

        measurment_string = ' '
        for i in range(50):
            measurment_string += str(real_val) + ',' + str(imaginary_val) + ','
        # doing the measurement and reading out some time
        self.simulated_state.simulated_time += self.communication_delay
        # removed last comma by adding slicing([:-1])
        return measurment_string[:-1]

    def get_list_of_measurement_values(self, trace, result_format):
        # get measurement string converted in list
        measurements = self.get_measurement_string(trace, result_format)
        result = []
        for x in measurements.split(',')[10:]:
            if x != '0' and x != '-999':  # no value is indicated with 0 for SDAT and -999 for FDAT
                result.append(float(x))
        return result

    def load_config(self, config_file, frequency):
        pass

    def do_single_sweep(self):
        pass