#include "csv_parser.h"
#include "csv.tab.h"
#include <stdlib.h>
#include <string.h>

/* External declarations from Bison/Flex - updated for reentrant API */
typedef void *yyscan_t;

extern int csvlex_init(yyscan_t *scanner);
extern int csvlex_destroy(yyscan_t scanner);
extern void csvset_in(FILE *file, yyscan_t scanner);
extern int csvparse(void *parser_state, yyscan_t scanner);

/* CSV parser structure - now contains all the state that was previously global */
struct csv_parser {
    char error_message[256];
    bool has_error;
    vector *current_records;    /* Vector of csv_record_t* */
    bool parse_error;
    char parse_error_message[256];
    int error_line;
    int error_column;
    int expected_field_count;   /* Field count from first record (-1 if not set) */
    int current_record_number;  /* Track record number for error reporting */
};

/* Helper functions */
static csv_record_t *create_record_from_vector(vector *field_vector);
static void csv_record_destructor(void *record_ptr, void *aux);

/* Functions called by the Bison parser */
void csv_parser_add_record(void *parser_state, vector *fields);
void csv_parser_set_error_with_location(void *parser_state, const char *error, int line, int column);

/* Implementation */

csv_parser_t *csv_parser_create(void)
{
    csv_parser_t *parser = malloc(sizeof(csv_parser_t));
    if (!parser) {
        return NULL;
    }
    
    parser->error_message[0] = '\0';
    parser->has_error = false;
    parser->current_records = NULL;
    parser->parse_error = false;
    parser->parse_error_message[0] = '\0';
    parser->error_line = 0;
    parser->error_column = 0;
    parser->expected_field_count = -1;
    parser->current_record_number = 0;
    
    return parser;
}

void csv_parser_destroy(csv_parser_t *parser)
{
    if (parser) {
        free(parser);
    }
}

csv_error_t csv_parser_parse_string(csv_parser_t *parser, const char *input, vector **records)
{
    if (!parser || !input || !records) {
        return CSV_ERROR_INVALID_PARAMETER;
    }
    
    *records = NULL;
    
    /* Create a temporary file from the string input */
    FILE *temp_file = tmpfile();
    if (!temp_file) {
        strncpy(parser->error_message, "Failed to create temporary file", sizeof(parser->error_message) - 1);
        parser->has_error = true;
        return CSV_ERROR_IO;
    }
    
    /* Write input to temporary file */
    if (fputs(input, temp_file) == EOF) {
        fclose(temp_file);
        strncpy(parser->error_message, "Failed to write to temporary file", sizeof(parser->error_message) - 1);
        parser->has_error = true;
        return CSV_ERROR_IO;
    }
    
    /* Reset file position to beginning */
    rewind(temp_file);
    
    /* Parse from the temporary file */
    csv_error_t result = csv_parser_parse_file(parser, temp_file, records);
    fclose(temp_file);
    
    return result;
}

csv_error_t csv_parser_parse_file(csv_parser_t *parser, FILE *file, vector **records)
{
    if (!parser || !file || !records) {
        return CSV_ERROR_INVALID_PARAMETER;
    }
    
    *records = NULL;
    parser->has_error = false;
    parser->error_message[0] = '\0';
    
    /* Initialize parser state */
    parser->current_records = v_new();
    if (!parser->current_records) {
        strncpy(parser->error_message, "Memory allocation failed", sizeof(parser->error_message) - 1);
        parser->has_error = true;
        return CSV_ERROR_MEMORY;
    }
    
    /* Set destructor for automatic cleanup */
    v_dtor(parser->current_records, csv_record_destructor, NULL);
    
    parser->parse_error = false;
    parser->parse_error_message[0] = '\0';
    parser->error_line = 0;
    parser->error_column = 0;
    parser->expected_field_count = -1;
    parser->current_record_number = 0;
    
    /* Initialize the reentrant scanner */
    yyscan_t scanner;
    int scanner_init_result = csvlex_init(&scanner);
    if (scanner_init_result != 0) {
        v_free(parser->current_records);
        parser->current_records = NULL;
        return CSV_ERROR_MEMORY;
    }
    
    /* Set up the lexer input */
    csvset_in(file, scanner);
    
    /* Parse the input */
    int parse_result = csvparse(parser, scanner);
    
    /* Clean up lexer state */
    csvlex_destroy(scanner);
    
    /* Check for errors */
    if (parse_result != 0 || parser->parse_error) {
        csv_error_t error_code;
        
        switch (parse_result) {
            case 2:
                /* Memory exhaustion in parser */
                strncpy(parser->error_message, "Parser memory exhaustion", sizeof(parser->error_message) - 1);
                error_code = CSV_ERROR_MEMORY;
                break;
                
            case 1:
                /* Parse error (syntax error or YYABORT) */
                if (parser->parse_error_message[0] != '\0') {
                    strncpy(parser->error_message, parser->parse_error_message, sizeof(parser->error_message) - 1);
                } else {
                    strncpy(parser->error_message, "Syntax error", sizeof(parser->error_message) - 1);
                }
                error_code = CSV_ERROR_PARSE;
                break;
                
            default:
                /* Other non-zero return or parser->parse_error flag set */
                if (parser->parse_error_message[0] != '\0') {
                    strncpy(parser->error_message, parser->parse_error_message, sizeof(parser->error_message) - 1);
                } else {
                    strncpy(parser->error_message, "Parse error", sizeof(parser->error_message) - 1);
                }
                error_code = CSV_ERROR_PARSE;
                break;
        }
        
        parser->has_error = true;
        v_free(parser->current_records);
        parser->current_records = NULL;
        return error_code;
    }
    
    /* Success - transfer ownership of records vector */
    *records = parser->current_records;
    parser->current_records = NULL;
    
    return CSV_SUCCESS;
}

csv_error_info_t csv_parser_get_error_info(csv_parser_t *parser)
{
    csv_error_info_t info = {0};
    
    if (!parser) {
        info.message = "Invalid parser";
        info.line = 0;
        info.column = 0;
        info.has_location = false;
        return info;
    }
    
    if (parser->has_error) {
        info.message = parser->error_message;
        info.line = parser->error_line;
        info.column = parser->error_column;
        info.has_location = (parser->error_line > 0);
    } else {
        info.message = "No error";
        info.line = 0;
        info.column = 0;
        info.has_location = false;
    }
    
    return info;
}

const char *csv_error_string(csv_error_t error)
{
    switch (error) {
        case CSV_SUCCESS:
            return "Success";
        case CSV_ERROR_MEMORY:
            return "Memory allocation error";
        case CSV_ERROR_PARSE:
            return "Parse error";
        case CSV_ERROR_INVALID_PARAMETER:
            return "Invalid parameter";
        case CSV_ERROR_IO:
            return "I/O error";
        default:
            return "Unknown error";
    }
}

/* Internal helper functions */

static csv_record_t *create_record_from_vector(vector *field_vector)
{
    if (!field_vector) {
        return NULL;
    }
    
    csv_record_t *record = malloc(sizeof(csv_record_t));
    if (!record) {
        return NULL;
    }
    
    /* Take ownership of the vector directly */
    record->fields = field_vector;
    
    return record;
}

static void csv_record_destructor(void *record_ptr, void *aux)
{
    (void)aux; /* Unused parameter */
    csv_record_t *record = (csv_record_t *)record_ptr;
    if (record) {
        if (record->fields) {
            /* The fields vector already has derp_free as its destructor set in yacc,
               so v_free will automatically clean up the strings */
            v_free(record->fields);
        }
        free(record);
    }
}

/* Functions called by the Bison parser */

void csv_parser_add_record(void *parser_state, vector *fields)
{
    csv_parser_t *parser = (csv_parser_t *)parser_state;
    if (!parser || !parser->current_records || parser->parse_error) {
        return;
    }
    
    /* Skip empty records (single empty field) */
    if (fields && v_length(fields) == 1) {
        char *first_field = v_at(fields, 0);
        if (first_field && first_field[0] == '\0') {
            return;
        }
    }
    
    parser->current_record_number++;
    int field_count = v_length(fields);
    
    /* Set expected field count from first record */
    if (parser->expected_field_count == -1) {
        parser->expected_field_count = field_count;
    } else if (field_count != parser->expected_field_count) {
        /* Field count mismatch - RFC 4180 violation */
        parser->parse_error = true;
        snprintf(parser->parse_error_message, sizeof(parser->parse_error_message) - 1,
                "Field count mismatch: record %d has %d fields, expected %d",
                parser->current_record_number, field_count, parser->expected_field_count);
        return;
    }
    
    csv_record_t *record = create_record_from_vector(fields);
    if (!record) {
        parser->parse_error = true;
        strncpy(parser->parse_error_message, "Memory allocation failed while creating record", sizeof(parser->parse_error_message) - 1);
        return;
    }
    
    /* Add to records vector */
    if (!v_append(parser->current_records, record)) {
        parser->parse_error = true;
        strncpy(parser->parse_error_message, "Failed to add record to vector", sizeof(parser->parse_error_message) - 1);
        csv_record_destructor(record, NULL);
        return;
    }
}

void csv_parser_set_error_with_location(void *parser_state, const char *error, int line, int column)
{
    csv_parser_t *parser = (csv_parser_t *)parser_state;
    if (!parser) {
        return;
    }
    
    parser->parse_error = true;
    parser->error_line = line;
    parser->error_column = column;
    if (error) {
        strncpy(parser->parse_error_message, error, sizeof(parser->parse_error_message) - 1);
        parser->parse_error_message[sizeof(parser->parse_error_message) - 1] = '\0';
    }
}