from __future__ import print_function

import subprocess
import time

import epics

from helpers import mgnt_utilities as utilities
from helpers.mgnt_facility_agent import FacilityAgent, CAException
from .mgnt_auto_checkout_test import AutoCheckoutTest


class CalibrateTest(AutoCheckoutTest):
    test_id = 'calibrate'
    description = 'Calibrate'
    read_only = False
    deferred = False

    def __init__(self):
        super(CalibrateTest, self).__init__(
            pre_checkout_routines=[]
        )

    def execute(self, magnet):
        """Performs calibration test.

        1. N/A if magnet has calibration disabled.
        2. N/A if magnet is not in service.
        3. Attempt to turn on magnet by running `caput <magnet>:STATESETPT 1`.
        4. FAIL if `caput` times out.
        5. Wait 2 seconds
        6. Attempt to `caget <magnet>:STATE`.
        7. FAIL if `caget` times out.
        8. FAIL if `<magnet>:STATE` is `OFF`.
        9. Attempt to `caget <magnet>:CALBOK`.
        10. FAIL if `caget` times out.
        11. FAIL if `CALBOK` is `0`.
        12. Attempt to `caget <magnet>:CALBTOD`.
        13. FAIL if `caget` times out.
        14. Report value of `CALBTOD` and PASS.

        Args:
            magnet (dict): Information about a magnet from Oracle (Elements, Polynomial, Additional Data)

        Returns:
            None

        """
        # Ensure calibrate is enabled
        if not utilities.results['calb_enabled'].data.startswith('Enabled'):
            self.status = None
            return

        # Ensure device is in service
        if utilities.results['in_service'].data != 'In-Service':
            self.status = None
            return

        # Turn device on
        state_set_pt_pv = '{}:STATESETPT'.format(magnet['device'])
        agent = FacilityAgent(utilities.facility)
        try:
            agent.caput(state_set_pt_pv, 1)
        except (subprocess.CalledProcessError, CAException) as e:
            self.data = 'Error trying to power on {}: {}'.format(magnet['device'], e.output.decode('utf-8'))
            self.status = False
            print('FAIL')
            return

        # Wait 2 seconds
        time.sleep(2)

        # Verify that device is on
        state_pv = '{}:STATE'.format(magnet['device'])
        state = epics.caget(state_pv, as_string=True)
        if state is None:
            self.data = '{} not found'.format(state_pv)
            self.status = False
            print('FAIL')
            return

        elif state != 'ON':
            self.data = '{} is expected to be on but {} is {}'.format(magnet['device'], state_pv, state)
            self.status = False
            print('FAIL')
            return

        # # Check that ICTRL and IACT exist and monitor
        # fields = ['ICTRL', 'IACT']
        # pvs = ['{}:{}'.format(magnet['device'], field) for field in fields]
        # for pv in pvs:
        #     value = epics.caget(pv)
        #     if value is None:
        #         self.data = '{} not found'.format(pv)
        #         self.status = False
        #         print 'FAIL'
        #         return
        #
        #     epics.camonitor(pv, callback=self.record_data)
        #
        # # Begin calibration
        # ctrl_pv = '{}:CTRL'.format(magnet['device'])
        # agent = FacilityAgent(utilities.facility)
        # try:
        #     agent.caput(ctrl_pv, 'CALB')
        # except (subprocess.CalledProcessError, CAException) as e:
        #     for pv in pvs:
        #         epics.camonitor_clear(pv)
        #
        #     self.data = 'Error trying to calibrate {}: {}'.format(magnet['device'], e.output.decode('utf-8'))
        #     self.status = False
        #     print 'FAIL'
        #     return
        #
        # # Wait until calibration is done
        # ctrl_state_pv = magnet['device'] + ':CTRLSTATE'
        # ctrl_state = epics.caget(ctrl_state_pv, as_string=True)
        # while ctrl_state != 'Done':
        #     if ctrl_pv is None:
        #         for pv in pvs:
        #             epics.camonitor_clear(pv)
        #
        #         self.data = '{} not found'.format(ctrl_state_pv)
        #         self.status = False
        #         print 'FAIL'
        #
        #     print 'Not done calibrating yet, waiting...'
        #     time.sleep(1)
        #     ctrl_state = epics.caget(ctrl_state_pv, as_string=True)
        #
        # # Stop monitoring ICTRL and IACT
        # for pv in pvs:
        #     epics.camonitor_clear(pv)
        #
        # # Check if calibration was successful
        # calb_ok_pv = '{}:CALBOK'.format(magnet['device'])
        # calb_ok = epics.caget(calb_ok_pv)
        # if calb_ok is None:
        #     self.data = '{} not found'.format(calb_ok_pv)
        #     self.status = False
        #     print 'FAIL'
        #     return
        #
        # if not calb_ok:
        #     snl_stat_msg_pv = '{}:SNLSTATMSG'.format(magnet['device'])
        #     snl_stat_msg = epics.caget(snl_stat_msg_pv)
        #     self.data = 'Calibrate failed: {}'.format(snl_stat_msg)
        #     self.status = False
        #     print 'FAIL'
        #     return
        # Skip calibration since sequencer has bugs

        # Check if calibration was successful
        calb_ok_pv = '{}:CALBOK'.format(magnet['device'])
        calb_ok = epics.caget(calb_ok_pv)
        if calb_ok is None:
            self.data = '{} not found'.format(calb_ok_pv)
            self.status = False
            print('FAIL')
            return

        if not calb_ok:
            self.data = 'Calibrate failed: {} is {}'.format(calb_ok_pv, calb_ok)
            self.status = False
            print('FAIL')
            return

        psc_calb_ok = '{}:CALBOK'.format(magnet['psc_device'])
        calb_ok_r = epics.caget(psc_calb_ok, as_string=True)
        if calb_ok_r is None:
            self.data = '{} not found'.format(psc_calb_ok)
            self.status = False
            print('FAIL')
            return

        if not calb_ok_r:
            self.data = 'Calibrate failed: {} is {}'.format(psc_calb_ok, calb_ok_r)
            self.status = False
            print('FAIL')
            return

        detail_lines = ['Calibrate successful']

        # Save calibration time
        calb_tod_pv = '{}:CALBTOD'.format(magnet['device'])
        calb_tod = epics.caget(calb_tod_pv)
        if calb_tod is None:
            self.data = '{} not found'.format(calb_tod_pv)
            self.status = False
            print('FAIL')
            return

        detail_lines.append('{} = {}'.format(calb_tod_pv, calb_tod))
        self.data = '\n'.join(detail_lines)
        self.status = True
        print('PASS')
