import asyncio
from collections.abc import Iterable, Sequence
from dataclasses import dataclass
from logging import debug
import logging
from typing import Optional

from logger import spr
from norsonic_parser import parse_report
import thrust_stand
import norsonic

from norsonic_fetcher import nor_get_reports
from thrust_stand import ThrustStand, ThrustStandMeasurement

@dataclass(frozen=True)
class OpPointData:
    data_thrust_stand: Sequence[ThrustStandMeasurement]
    raw_nor_report: Optional[bytes]

    @property 
    def data_accustic(self):
        if self.raw_nor_report is None:
            raise ValueError()
        return parse_report(self.raw_nor_report)

    @property
    def data_thrust_stand_avg(self):
        return sum(self.data_thrust_stand, ThrustStandMeasurement.zero())/len(self.data_thrust_stand)

    @property
    def data_accustic_avg(self):
        return {k: sum(map(float, (row[k] for row in self.data_accustic)))/len(self.data_accustic) for k in self.data_accustic[0].keys() if k != 'Date'}

import sys
async def ainput(string: str) -> str:
    await asyncio.get_event_loop().run_in_executor(
            None, lambda s=string: sys.stdout.write(s+' '))
    return await asyncio.get_event_loop().run_in_executor(
            None, sys.stdin.readline)


@dataclass
class ConnectionParams:
    stand_tty: str
    nor_addr: str
    nor_ftp_user: str
    nor_ftp_pass: str
    nor_recordings_dir: str

async def meas_series(params: ConnectionParams, pwms: Iterable[int]):
    stand = await ThrustStand.open_connection(params.stand_tty)
    nor = await norsonic.open_connection(params.nor_addr)

    results_stand = {}
    files_nor = {}

    # TODO TARA
    sample,  = stand.get_samples_raw(1)
    stand.tare_thrust = thrust_stand.raw_thrust(sample.load_thrust)
    stand.tare_torque = thrust_stand.raw_torque(sample.load_left, sample.load_right)
    stand.tare_current = sample.esc_current

    stand.mot_pwm = 1000

    ####
    # stand.mot_pwm = 1200
    # await ainput("Press Enter to continue...")

    
    for pwm in pwms:
        stand.mot_pwm = pwm
        spr(f'Output: {pwm}PWM')
        await stand.stabilize_rpm(10, 4)
        spr(f'Starting measurement')
        stand_series_pending = stand.start_meas_series()
        #
        files_nor[pwm] = await norsonic.record(nor)
        await asyncio.sleep(1)
        spr(f'Done')
        results_stand[pwm] =  stand.finish_meas_series(stand_series_pending)
        print(results_stand[pwm][0])

    while stand.mot_pwm > 1000:
        stand.mot_pwm -= 10
        await asyncio.sleep(0.1)

    stand.mot_pwm = 1000

    await asyncio.sleep(3)

    spr('Downlaoding reports')


    nor_reports = await nor_get_reports(params.nor_addr, params.nor_ftp_user, params.nor_ftp_pass, [files_nor[pwm] for pwm in pwms])
    spr('Done')

    ret = {
            pwm: OpPointData(
                data_thrust_stand=results_stand[pwm],
                # raw_nor_report=None
                raw_nor_report=nor_reports[i]
                ) for i, pwm in enumerate(pwms)
            }
    return ret