#!/usr/bin/env python
# ==============================================================
#
#  Abs:   Script for automated checkout of magnets
#
#  Name:  mgnt_auto_checkout.py
#
#  Usage: mgnt_auto_checkout.py [-h] [-f FACILITY]
#                               (-a AREA | -e ELEMENT | -d DEVICE) [-n]
#
#  Facility: SLAC Controls (Development)
#
#  Auth:  08-Nov-2021, A. Le    (anle)
# --------------------------------------------------------------
#  Mods: (Latest to oldest)
#     23-Sep-2022, A. Le        (anle)
#         Add option to get magnets from csv file
#     19-Sep-2022, A. Le        (anle)
#         Add option to show last results
#     09-Sep-2022, A. Le        (anle)
#         Add option to list missing magnets
#     11-Aug-2022, A. Le        (anle)
#         Add option to specify magnets by IOC
#     05-Jul-2022, A. Le        (anle)
#         Add option to list passing magnets
#     09-Jun-2022, A. Le        (anle)
#         Print failed magnets if -lf is specified
#     07-Jun-2022, A. Le        (anle)
#         Write back to JSON file only if checkout data changes
#     06-Jun-2022, A. Le        (anle)
#         Allow user to specify multiple tests
#         Allow user to specify multiple areas, elements, or
#           device names
#     03-Jun-2022, A. Le        (anle)
#         Add option to skip tests
#     02-Jun-2022, A. Le        (anle)
#         Add verbose option
#     26-May-2022, A. Le        (anle)
#         Add option to list failed tests
#     20-May-2022, A. Le        (anle)
#         Add option to run LGPS power test only
#     09-May-2022, A. Le        (anle)
#         Show message when running ACSW power test
#     06-May-2022, A. Le        (anle)
#         Add option to run ACSW power test only
#     02-May-2022, A. Le        (anle)
#         Add option to redo failed checks
#     21-Mar-2022, A. Le        (anle)
#         Add option to perform only read-only checks
#         Add read-only field to all tests
#         Add option to write output to local directory
#
# ==============================================================
#
from __future__ import print_function

import argparse
import sys

import helpers.mgnt_utilities as utilities
from mgnt_auto_checkout_data import AutoCheckoutData
from mgnt_auto_checkout_structure import AutoCheckoutStructure
from tests.mgnt_bulk_ps_ctrl_power_on_off_test import BulkPSCtrlPowerOnOffTest
from tests.mgnt_bulk_ps_direct_power_on_off_test import BulkPSDirectPowerOnOffTest
from tests.mgnt_general_acsw_power_test import GeneralACSWPowerTest
from tests.mgnt_multi_magnet_checkout_test import MultiMagnetCheckoutTest
from tests.mgnt_pre_checkout_routine import PreCheckoutRoutine

# Parse arguments
parser = argparse.ArgumentParser(description='Perform automated checkout of magnets')
parser.add_argument('-f', '--facility', help='Check out magnets in specified facility')
magnet_group = parser.add_mutually_exclusive_group(required=True)
magnet_group.add_argument('-a', '--area', nargs='*', help='Check out magnets in specified area(s)')
magnet_group.add_argument('-e', '--element', nargs='*', help='Check out specified element(s)')
magnet_group.add_argument('-d', '--device', nargs='*', help='Check out magnets by device name(s) (* and ? allowed)')
magnet_group.add_argument('-i', '--ioc', help='Check out magnets by IOC (PV or node name format OK)')
parser.add_argument('-n', '--no-caput', action='store_true', help='Disable writing to production PVs')
parser.add_argument('-r', '--read-only', action='store_true', help='Perform only read-only checks (implies --no-caput)')
parser.add_argument('-j', '--json-dir',
                    help='Write JSON output to directory (default: $MGNT_REPORT/data in specified facility)')
parser.add_argument('-c', '--csv', dest='csv_file', help='Get magnets from flat file instead of Oracle')
parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose logging')
fail_group = parser.add_mutually_exclusive_group()
fail_group.add_argument('-rf', '--redo-failed', action='store_true', help='Redo checks that failed on the previous run')
fail_group.add_argument('-lf', '--list-failed', action='store_true', help='List checks that failed on the previous run')
fail_group.add_argument('-lp', '--list-passed', action='store_true', help='List magnets that passed all tests')
fail_group.add_argument('-lm', '--list-missing', action='store_true',
                        help='List magnets that have not been fully tested')
fail_group.add_argument('-lr', '--last-results', action='store_true', help='Show the latest test results')
test_group = parser.add_mutually_exclusive_group()
test_group.add_argument('-t', '--test-id', nargs='*', help='Run test(s) by id')
test_group.add_argument('-s', '--skip-test-id', nargs='*', help='Skip test(s) by id')
test_group.add_argument('-A', '--acsw', help='Run power test for a single ACSW')
test_group.add_argument('-L', '--lgps', help='Run power test for a single LGPS')
if len(sys.argv) == 1:
    parser.print_help()
    parser.exit()

args = parser.parse_args()

# Get matching magnets
utilities.init(args.facility, args.json_dir, args.csv_file, args.verbose)
if args.area:
    matching_magnets = utilities.get_magnets_by_multiple('area', args.area)
elif args.element:
    matching_magnets = utilities.get_magnets_by_multiple('element', args.element)
elif args.device:
    matching_magnets = utilities.get_magnets_by_multiple('device', args.device, wildcard=True)
elif args.ioc:
    ioc_name = args.ioc.upper().replace('-', ':')
    matching_magnets = utilities.get_magnets_by('ioc', ioc_name)

elif args.acsw:
    matching_magnets = utilities.get_magnets_by('acsw_host', args.acsw)
elif args.lgps:
    matching_magnets = utilities.get_magnets_by('bulk_ps', args.lgps)
else:
    matching_magnets = utilities.get_all_magnets()

if not matching_magnets:
    raise ValueError('No matching magnets found')

PreCheckoutRoutine.magnets = matching_magnets
MultiMagnetCheckoutTest.magnets = matching_magnets

# Disable caput if needed
if args.no_caput or args.read_only:
    utilities.enable_writes = False
    if args.read_only:
        utilities.read_only = True

# If ACSW is provided, run power test
if args.acsw:
    test = GeneralACSWPowerTest()
    utilities.verbose_print('Running {} ({})'.format(type(test).__name__, test.description))
    test.execute(args.acsw)

elif args.lgps:
    # Perform LGPS power tests
    tests = [BulkPSDirectPowerOnOffTest(), BulkPSCtrlPowerOnOffTest()]
    for test in tests:
        utilities.verbose_print('Running {} ({})'.format(type(test).__name__, test.description))
        test.execute(args.lgps)

else:
    # Perform tests
    failing_magnets = []
    missing_magnets = []
    untested_magnets = []
    for magnet in matching_magnets:
        print('Checking out ' + magnet['element'])
        # Clear previous test results
        utilities.results = {}

        # Load json data
        json_file = '{}.json'.format(magnet['element'])
        checkout_data = AutoCheckoutData(args.facility, args.json_dir, magnet)
        checkout_data.load_json(json_file)
        if args.list_passed and len(checkout_data.data.keys()) <= 2:
            untested_magnets.append(magnet['element'])
            continue

        # Run tests
        checkout_structure = AutoCheckoutStructure()
        write_back = False
        for test in checkout_structure.test_iter(args.test_id, args.skip_test_id):
            prev_result = checkout_data.get_latest_result(test.test_id)
            if args.last_results:
                # Show test result
                if prev_result:
                    if prev_result['status']:
                        result_text = 'PASS: ' + prev_result['data']
                    elif prev_result['status'] is False:
                        result_text = 'FAIL: ' + prev_result['data']
                    else:
                        result_text = 'N/A'

                    print('{} ({}) - {}'.format(type(test).__name__, test.description, result_text))

            elif args.list_failed or args.list_passed:
                if prev_result and prev_result['status'] is False:
                    # If test failed last time, mention why
                    if args.list_failed:
                        print('{} ({}) - {}'.format(type(test).__name__, test.description, prev_result['data']))

                    if magnet['element'] not in failing_magnets:
                        failing_magnets.append(magnet['element'])

            elif args.list_missing:
                if prev_result and prev_result['status'] is None:
                    # Mention missing test
                    if args.list_failed:
                        print('{} ({}) - N/A'.format(type(test).__name__, test.description))

                    if magnet['element'] not in missing_magnets:
                        missing_magnets.append(magnet['element'])

            else:
                if args.redo_failed and prev_result and prev_result['status']:
                    # Skip test if it passed and we are in redo-failed mode
                    utilities.verbose_print(
                        'Skipping {} ({}) since it already passed'.format(type(test).__name__, test.description))
                    test.load_results(prev_result)
                    utilities.results[test.test_id] = test

                elif args.read_only and not test.read_only:
                    # Skip test if in read-only mode
                    utilities.verbose_print('Skipping {} ({})'.format(type(test).__name__, test.description))

                else:
                    utilities.verbose_print('Running {} ({})'.format(type(test).__name__, test.description))
                    test.execute(magnet)
                    utilities.results[test.test_id] = test

                    # Update json data
                    checkout_data.update(test)
                    write_back = True

        # Write back json data
        if write_back:
            checkout_data.save_json(json_file)

    # List failing magnets
    if failing_magnets and args.list_failed:
        print('Failing magnets:')
        print('\n'.join(failing_magnets))

    # List passed magnets
    if args.list_passed:
        passing_magnets = [magnet['element'] for magnet in matching_magnets if
                           magnet['element'] not in failing_magnets and magnet['element'] not in untested_magnets]
        print('Passing magnets:')
        print('\n'.join(passing_magnets))

    # List missing magnets
    if missing_magnets and args.list_missing:
        print('Missing magnets:')
        print('\n'.join(missing_magnets))
