#!/usr/bin/env python

r"""
This module is the python counterpart to obmc_boot_test.
"""

from tally_sheet import *
import gen_robot_print as grp
import gen_robot_plug_in as grpi
import state as st

import os
import time
import subprocess
import glob

from robot.utils import DotDict
from robot.libraries.BuiltIn import BuiltIn
from robot.libraries.OperatingSystem import OperatingSystem

# Create boot_results_fields for use in creating boot_results.
boot_results_fields = DotDict([('total', 0), ('pass', 0), ('fail', 0)])
# Create boot_results which is global to this module.
boot_results = tally_sheet('boot type',
                           boot_results_fields,
                           'boot_test_results')

boot_results.set_sum_fields(['total', 'pass', 'fail'])
boot_results.set_calc_fields(['total=pass+fail'])


###############################################################################
def plug_in_setup():

    r"""
    Initialize all plug-in environment variables for use by the plug-in
    programs.
    """

    boot_pass = int(BuiltIn().get_variable_value("${boot_pass}"))
    if boot_pass > 1:
        test_really_running = 1
    else:
        test_really_running = 0

    BuiltIn().set_global_variable("${test_really_running}",
                                  test_really_running)

    next_boot = BuiltIn().get_variable_value("${next_boot}")
    BuiltIn().set_global_variable("${boot_type_desc}", next_boot)

    # Setting master_pid correctly influences the behavior of plug-ins like
    # DB_Logging
    program_pid = BuiltIn().get_variable_value("${program_pid}")
    try:
        master_pid = OperatingSystem().get_environment_variable(
            "AUTOBOOT_MASTER_PID")
    except RuntimeError:
        master_pid = program_pid
    if master_pid == "":
        master_pid = program_pid

    BuiltIn().set_global_variable("${master_pid}", master_pid)

    seconds = time.time()
    loc_time = time.localtime(seconds)
    time_string = time.strftime("%y%m%d.%H%M%S.", loc_time)

    openbmc_nickname = BuiltIn().get_variable_value("${openbmc_nickname}")
    openbmc_host = BuiltIn().get_variable_value("${openbmc_host}")
    if openbmc_nickname == "":
        openbmc_nickname = openbmc_host
    ffdc_prefix = openbmc_nickname

    ffdc_prefix += "." + time_string

    try:
        ffdc_dir_path = os.environ['FFDC_DIR_PATH']
        # Add trailing slash.
        ffdc_dir_path = os.path.normpath(ffdc_dir_path) + os.sep
    except KeyError:
        ffdc_dir_path = ""
    BuiltIn().set_global_variable("${FFDC_DIR_PATH}", ffdc_dir_path)

    status_dir_path = os.environ.get('STATUS_DIR_PATH', "")
    if status_dir_path != "":
        # Add trailing slash.
        status_dir_path = os.path.normpath(status_dir_path) + os.sep
    BuiltIn().set_global_variable("${STATUS_DIR_PATH}", status_dir_path)

    base_tool_dir_path = os.environ.get('AUTOBOOT_BASE_TOOL_DIR_PATH', "/tmp")
    base_tool_dir_path = os.path.normpath(base_tool_dir_path) + os.sep
    BuiltIn().set_global_variable("${BASE_TOOL_DIR_PATH}", base_tool_dir_path)

    ffdc_list_file_path = base_tool_dir_path + openbmc_nickname +\
        "/FFDC_FILE_LIST"

    BuiltIn().set_global_variable("${FFDC_LIST_FILE_PATH}",
                                  ffdc_list_file_path)

    # For each program parameter, set the corresponding AUTOBOOT_ environment
    # variable value.  Also, set an AUTOBOOT_ environment variable for every
    # element in additional_values.
    additional_values = ["boot_type_desc", "boot_success", "boot_pass",
                         "boot_fail", "test_really_running", "program_pid",
                         "master_pid", "ffdc_prefix", "ffdc_dir_path",
                         "status_dir_path", "base_tool_dir_path",
                         "ffdc_list_file_path"]
    BuiltIn().set_global_variable("${ffdc_prefix}", ffdc_prefix)

    parm_list = BuiltIn().get_variable_value("@{parm_list}")

    plug_in_vars = parm_list + additional_values

    for var_name in plug_in_vars:
        var_value = BuiltIn().get_variable_value("${" + var_name + "}")
        var_name = var_name.upper()
        if var_value is None:
            var_value = ""
        OperatingSystem().set_environment_variable(
            "AUTOBOOT_" + var_name, var_value)

    debug = int(BuiltIn().get_variable_value("${debug}"))
    if debug:
        cmd_buf = "printenv | egrep AUTOBOOT_ | sort -u"
        grp.rpissuing(cmd_buf)
        sub_proc = subprocess.Popen(cmd_buf, shell=True,
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.STDOUT)
        out_buf, err_buf = sub_proc.communicate()
        shell_rc = sub_proc.returncode
        grp.rprint(out_buf)

###############################################################################


###############################################################################
def create_boot_results_table():

    r"""
    Create our boot_results_table.
    """

    # At some point we'll want to change to reading in our boot types from
    # some external source (e.g. file).

    boot_results.add_row('BMC Power On')
    boot_results.add_row('BMC Power Off')

###############################################################################


###############################################################################
def update_boot_results_table(boot_type,
                              boot_status):

    r"""
    Update our boot_results_table.  This includes:
    - Updating the record for the given boot_type by incrementing the pass or
      fail field.
    - Calling the calc method to have the totals, etc. calculated.
    - Updating global variables boot_pass/boot_fail.

    Description of arguments:
    boot_type    The type of boot just done (e.g. "BMC Power On").
    boot_status  The status of the boot just done.  This should be equal to
                 either "pass" or "fail" (case-insensitive).
    """

    boot_results.inc_row_field(boot_type, boot_status.lower())
    totals_line = boot_results.calc()

    # The caller of obmc_boot_test can pass boot_pass/boot_fail values because
    # the caller may have already done some testing (e.g. "BMC OOB").  For the
    # sake of DB logging done by plug-ins, we want to include these in our
    # overall totals.
    initial_boot_pass = int(BuiltIn().get_variable_value(
        "${initial_boot_pass}"))
    initial_boot_fail = int(BuiltIn().get_variable_value(
        "${initial_boot_fail}"))

    BuiltIn().set_global_variable("${boot_pass}",
                                  totals_line['pass'] + initial_boot_pass)
    BuiltIn().set_global_variable("${boot_fail}",
                                  totals_line['fail'] + initial_boot_fail)

###############################################################################


###############################################################################
def print_boot_results_table(header_footer="\n"):

    r"""
    Print the formatted boot_resuls_table to the console.
    """

    grp.rqprint(header_footer)
    grp.rqprint(boot_results.sprint_report())
    grp.rqprint(header_footer)

###############################################################################


###############################################################################
def select_boot(state):

    r"""
    Select a boot test to be run based on our current state and return the
    chosen boot type.

    Description of arguments:
    state  The state of the machine, which will include the power state..
    """

    if 'chassis' in state:
        # New style state.
        if state['chassis'] == 'Off':
            boot = 'BMC Power On'
        else:
            boot = 'BMC Power Off'
    else:
        # Old style state.
        if state['power'] == 0:
            boot = 'BMC Power On'
        else:
            boot = 'BMC Power Off'

    return boot

###############################################################################


###############################################################################
def my_ffdc():

    r"""
    Collect FFDC data.
    """

    plug_in_setup()
    rc, shell_rc, failed_plug_in_name = grpi.rprocess_plug_in_packages(
        call_point='ffdc', stop_on_plug_in_failure=1)

    AUTOBOOT_FFDC_PREFIX = os.environ['AUTOBOOT_FFDC_PREFIX']

    # FFDC_LOG_PATH is used by "FFDC" keyword.
    FFDC_DIR_PATH = BuiltIn().get_variable_value("${FFDC_DIR_PATH}")
    BuiltIn().set_global_variable("${FFDC_LOG_PATH}",
                                  FFDC_DIR_PATH)

    cmd_buf = ["FFDC", "ffdc_prefix=" + AUTOBOOT_FFDC_PREFIX]
    grp.rpissuing_keyword(cmd_buf)
    BuiltIn().run_keyword(*cmd_buf)

    state = st.get_state()
    BuiltIn().set_global_variable("${state}",
                                  state)

    cmd_buf = ["Print Defect Report"]
    grp.rpissuing_keyword(cmd_buf)
    BuiltIn().run_keyword(*cmd_buf)

###############################################################################


###############################################################################
def print_last_boots():

    r"""
    Print the last ten boots done with their time stamps.
    """

    # indent 0, 90 chars wide, linefeed, char is "="
    grp.rqprint_dashes(0, 90)
    grp.rqprintn("Last 10 boots:\n")
    last_ten = BuiltIn().get_variable_value("${LAST_TEN}")

    for boot_entry in last_ten:
        grp.rqprint(boot_entry)
    grp.rqprint_dashes(0, 90)

###############################################################################


###############################################################################
def print_test_start_message(boot_keyword):

    r"""
    Print a message indicating what boot test is about to run.

    Description of arguments:
    boot_keyword  The name of the boot which is to be run
                  (e.g. "BMC Power On").
    """

    doing_msg = gp.sprint_timen("Doing \"" + boot_keyword + "\".")
    grp.rqprint(doing_msg)

    last_ten = BuiltIn().get_variable_value("${LAST_TEN}")
    last_ten.append(doing_msg)

    if len(last_ten) > 10:
        del last_ten[0]

###############################################################################


###############################################################################
def print_defect_report():

    r"""
    Print a defect report.
    """

    grp.rqprintn()
    # indent=0, width=90, linefeed=1, char="="
    grp.rqprint_dashes(0, 90, 1, "=")
    grp.rqprintn("Copy this data to the defect:\n")

    parm_list = BuiltIn().get_variable_value("${parm_list}")

    grp.rqpvars(*parm_list)

    grp.rqprintn()

    print_last_boots()
    grp.rqprintn()
    state = BuiltIn().get_variable_value("${state}")
    grp.rqpvar(state)

    # At some point I'd like to have the 'Call FFDC Methods' return a list
    # of files it has collected.  In that case, the following "ls" command
    # would no longer be needed.  For now, however, glob shows the files
    # named in FFDC_LIST_FILE_PATH so I will refrain from printing those
    # out (so we don't see duplicates in the list).

    LOG_PREFIX = BuiltIn().get_variable_value("${LOG_PREFIX}")

    output = '\n'.join(glob.glob(LOG_PREFIX + '*'))

    FFDC_LIST_FILE_PATH = \
        BuiltIn().get_variable_value("${FFDC_LIST_FILE_PATH}")

    try:
        ffdc_list = open(FFDC_LIST_FILE_PATH, 'r')
    except IOError:
        ffdc_list = ""

    status_file_path = BuiltIn().get_variable_value("${status_file_path}")

    grp.rqprintn()
    grp.rqprintn("FFDC data files:")
    if status_file_path != "":
        grp.rqprintn(status_file_path)

    grp.rqprintn(output)
    # grp.rqprintn(ffdc_list)
    grp.rqprintn()

    grp.rqprint_dashes(0, 90, 1, "=")

###############################################################################