/************************************************************************
 *
 * output.cpp - Definitions of the result parsing subsystem
 *
 * $Id$
 *
 ************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 * 
 **************************************************************************/

#include <assert.h>
#include <errno.h>
#include <stdio.h> /* for printf, puts, FILE, f* */
#include <stdlib.h> /* for exit, free */
#include <string.h> /* for str* */

#include <sys/types.h>

#include <sys/stat.h>

#include "cmdopt.h"
#include "display.h"
#include "util.h"

#include "output.h"

#ifndef ENOENT
#  define ENOENT 2
#endif   /* ENOENT */


/**
   Parses contents of the open file handle data for test target_name.
   
   This method reads the data file handle, looking for the output summary from 
   the test driver.  The results of this search (and the parsing of this 
   summary, if found) are stored in the status structure.

   @param data pointer to file structure for output file being parsed
   @param status status object to record results in.
*/
static void
check_test (FILE* data, struct target_status* status)
{
    unsigned r_lvl    = 0;   /* diagnostic severity level */
    unsigned r_active = 0;   /* number of active diagnostics */
    unsigned r_total  = 0;   /* total number of diagnostics */

    int fmt_ok = 0;          /* is output format okay? */

    unsigned fsm = 0;        /* state */
    char tok;                /* current character */

    const char* const target_name = get_target ();

    assert (0 != target_name);
    assert (0 != data);
    assert (0 != status);

    tok = fgetc (data);

    if (feof (data)) {
        /* target produced no output (regression test?) */
        status->status = ST_NO_OUTPUT;
        return;
    }

    for ( ; fsm < 6 && !feof (data); tok = fgetc (data)) {
        switch (tok) {
        case '\n':
            fsm = 1;
            break;
        case '#':
            fsm = (1 == fsm) ? 2 : 0;
            break;
        case ' ':
            fsm = (2 == fsm) ? 3 : ((4 == fsm) ? 5 : 0);
            break;
        case '|':
            fsm = (3 == fsm) ? 4 : 0;
            break;
        case '(':
            if (5 == fsm) {
                fseek (data, -6, SEEK_CUR);
                fsm++;
                break;
            }
        default:
            fsm = 0;
        }
    }

    if (!feof (data)) {
        while (3 == fscanf (data, "# | (S%u) %*s | %u | %u | %*u%% |\n", 
                            &r_lvl, &r_active, &r_total)) {
            if (6 < r_lvl) {
                /* The 0.new tests produces errors, and are all 
                   expected to be active, so invert the total */
                if (8 == r_lvl && 0 == strcmp (target_name, "0.new"))
                    r_active = r_total-r_active;
                status->failed += r_active;
                status->assert += r_total;
                if (   status->failed < r_active 
                    || status->assert < r_total
                    || (unsigned int)-1 == status->assert) {
                    status->status = ST_OVERFLOW;
                    return;
                }
            }
            else if (1 < r_lvl) {
                status->t_warn += r_active;
                if (status->t_warn < r_active) {
                    status->t_warn = (unsigned int)-1;
                }
            }
            fmt_ok = 1;
        }
    }
    
    if (!fmt_ok)
        status->status = ST_FORMAT;
}

/**
   Parses contents of the open file handle data for test target_name.
   
   This method is a reimplementation of check_test ().  The difference between
   this method and check_test () is how it parses the results.  This version
   parses compatability layer output, rather than the test driver output.

   @param data pointer to file structure for output file being parsed
   @see check_test ()
*/
static void
check_compat_test (FILE* data, struct target_status* status)
{
    int read = 0;
    unsigned fsm = 0;
    char tok;

    assert (0 != data);
    assert (0 != status);

    tok = fgetc (data);

    if (feof (data)) {
        /* target produced no output (regression test?) */
        status->status = ST_NO_OUTPUT;
        return;
    }

    for ( ; !feof (data); tok = fgetc (data)) {
        switch (tok) {
        case '\n':
            fsm = 1;
            break;
        case '#':
            if (1 == fsm || 2 == fsm)
                ++fsm;
            else
                fsm = 0;
            break;
        case ' ':
            if (3 == fsm) 
                ++fsm;
            else
                fsm = 0;
            break;
        case 'W':
            if (4 == fsm && !feof (data)) /* leading "## W" eaten */
                read = fscanf (data, "arnings = %u\n## Assertions = %u\n"
                       "## FailedAssertions = %u",
                       &status->t_warn, &status->assert, &status->failed);
        default:
            fsm = 0;
        }
    }
    if (3 != read) {
        status->status = ST_FORMAT;
    }
}

/**
   Arbitrary constant controling static read buffer size.

   @see check_example ()
*/
#define DELTA_BUF_LEN 64

/**
   Parses output file out_name for the example target_name.
   
   This method tries to compare out_name against a reference output file and
   reports the result of the comparison.  If the comparison fails to result in
   a match, status->status is set to the appropriate error state.  The 
   reference file name is generated by the reference_name function.

   Reference file locations:
     - [data_dir]/manual/out/[target_name].out
     - [data_dir]/tutorial/out/[target_name].out

   @todo add logic to handle differing line endings (CR vs LF vs CRLF)

   @param out_name the name of the output file
   @param fout pointer to file structure for output file being parsed
   @param status status object to record results in.
   @see reference_name
*/
static void
check_example (const char* const data_dir, char* const out_name, FILE* fout, 
               struct target_status* status)
{
    struct stat file_info;
    char* ref_name;

    FILE* fref;   /* reference file (expected output) */

    assert (0 != out_name);
    assert (0 != fout);
    assert (0 != status);

    /* Mark as an example by setting assertions to -1 */
    status->assert = (unsigned)-1;

    /* Try data_dir/manual/out/target_name.out */
    ref_name = reference_name (data_dir, "manual", "out");

    if (0 > stat (ref_name, &file_info)) {
        if (ENOENT != errno) {
            warn ("stat (%s) error: %s\n", exe_name, ref_name, 
                  strerror (errno));
            status->status = ST_BAD_REF;
            free (ref_name);
            return;
        }
                        
        /* If that doesn't exist, try 
           data_dir/tutorial/out/target_name.out */
        free (ref_name);
        ref_name = reference_name (data_dir, "tutorial", "out");

        if (0 > stat (ref_name, &file_info)) {
            if (ENOENT != errno) {
                warn ("stat (%s) error: %s\n", exe_name, ref_name, 
                      strerror (errno));
                status->status = ST_BAD_REF;
            }
            else
                status->status = ST_NO_REF;

            free (ref_name);
            return;
        }
    }

    fref = fopen (ref_name, "r");

    if (0 == fref) {
        int cache = errno; /* caching errno, as puts could alter it */
        if (ENOENT != cache)
            warn ("Error opening %s: %s\n", ref_name, strerror (cache));
        status->status = ST_BAD_REF;
    }
    else {
        int match = 1;   /* do the two files match? */

        while (!feof (fref) && !feof (fout)) {

            char buf [2][DELTA_BUF_LEN];

            size_t nread [2];   /* bytes read from the output/ref file */

            /* First, read a block from the files into the buffer */
            nread [0] = fread (buf [0], 1, sizeof buf [0], fout);
            if (ferror (fout)) {
                warn ("Error reading %s: %s\n", out_name, strerror (errno));
                match = 0;
                break;
            }

            nread [1] = fread (buf [1], 1, sizeof buf [1], fref);
            if (ferror (fref)) {
                warn ("Error reading %s: %s\n", ref_name, strerror (errno));
                match = 0;
                break;
            }

            /* Then, check if the amount of data read or the state of the 
               files differs
            */
            if (nread [0] != nread [1] || feof (fref) != feof (fout)) {
                match = 0;
                break;
            }

            /* Finally, check if the contents of the buffers differ */
            if (0 != memcmp (buf [0], buf [1], nread [0])) {
                match = 0;
                break;
            }
        }

        if (!match)
            status->status = ST_BAD_OUTPUT;

        fclose (fref);
    }
    free (ref_name);
}

void
parse_output (const struct target_opts* options, struct target_status* status)
{
    char* out_name;
    FILE* data;

    assert (0 != status);
    assert (0 != options->argv [0]);
    out_name = output_name (options->argv [0]);

    data = fopen (out_name, "r");

    if (0 == data) {
        if (ENOENT != errno)
            warn ("Error opening %s: %s\n", out_name, strerror (errno));
        status->status = ST_NO_OUTPUT;
    }
    else {
        if (0 == options->data_dir || '\0' == *options->data_dir) {
            /* If there is not an input directory, look at the assertion tags */

            if (!options->compat)
                check_test (data, status);
            else
                check_compat_test (data, status);
        }
        else {
            /* Otherwise, diff against the output file */
            check_example (options->data_dir, out_name, data, status);
        }
        fclose (data);
    }
    free (out_name);
}