#include <QDebug>
#include "fiebdc.h"
//#include "globalvars.h" // Asumiendo que globalVars está definido aquí

#include <QDate>

FIEBDC::FIEBDC(QString filename, Budget* budget) {
    __budget = budget;
    __filename = filename;
    if (__budget != nullptr) {
        __budget->filename = __filename;
    }
    __cancel = false;
    __format_list = {"FIEBDC-3/95", "FIEBDC-3/98", "FIEBDC-3/2002",
                     "FIEBDC-3/2004", "FIEBDC-3/2007"};
    __character_sets_dict = {{"ANSI", "cp1252"},
                             {"850", "850"},
                             {"437", "cp437"}};
    __file_format = "FIEBDC-3/2007";
    //__generator = globalVars.name + " " + globalVars.version;

    __character_set = "850";
    initializePatterns();
}

void FIEBDC::initializePatterns() {
    __pattern = {
        {"control_tilde", QRegularExpression(R"(((\r\n)| |\t)+~)")},
        {"control_vbar", QRegularExpression(R"(((\r\n)| |\t)+\|)")},
        {"control_backslash", QRegularExpression(R"(((\r\n)| |\t)+\\)")},
        {"valid_code", QRegularExpression(R"([^A-Za-z0-9ñÑ.$#%&_])")},
        {"special_char", QRegularExpression(R"([#%&])")},
        {"no_float", QRegularExpression(R"([^\-0-9.])")},
        {"formula", QRegularExpression(R"(.*[^0123456789\.()\+\-\*/\^abcdp ].*)")},
        {"comment", QRegularExpression(R"(#.*\r\n)")},
        {"empty_line", QRegularExpression(R"((\r\n) *\r\n)")},
        {"space_before_backslash", QRegularExpression(R"(( )+\\)")},
        {"space_after_backslash", QRegularExpression(R"(\\( )+)")},
        {"start_noend_backslash", QRegularExpression(R"((\r\n\\\.*[^\\\])\r\n)")},
        {"end_oper", QRegularExpression(R"((\+|-|\*|/|/^|@|&|<|>|<=|>=|=|!) *\r\n)")},
        {"matricial_var", QRegularExpression(R"((\r\n *[%|\$][A-ZÑ].*=.*, ) *\r\n)")},
        {"descomposition", QRegularExpression(R"(^([^:]+):(.*)$)")},
        {"var", QRegularExpression(R"(^([$%][A-ZÑ][()0-9, ]*)=(.*)$)")},
        {"after_first_tilde", QRegularExpression(R"(^[^~]*~)")},
        {"end_control", QRegularExpression(R"(((\r\n)| |\t)+$)")}
    };
}

void FIEBDC::cancel() {
    __cancel = true;
}

QString FIEBDC::eraseControlCharacters(const QString& input) {
    // Implementación de la función para eliminar caracteres de control
    QString string = input;
    string = string.replace(__pattern["control_tilde"], "~");
    string = string.replace(__pattern["control_vbar"], "|");
    // Uncomment if control_backslash processing is needed
    // string = string.replace(__pattern["control_backslash"], "\\");
    return string;
}

bool FIEBDC::validateCode(const QString& code) {
    // Implementación de la función para validar el código
    QRegularExpression re("^[A-Z0-9]+$");
    return re.match(code).hasMatch();
}

QDate FIEBDC::parseDate(const QString& dateStr) {
    /*parseDate(date)

    date: in the format:
        uneven len: add a Leading 0
        len = 8  DDMMYYYY
        len <= 6 DDMMYY “80/20”. >80 -> >1980 <80 -> <2080
        len < 5  MMYY
        len < 3  YY
    Test date string and return a tuple (YYYY, MM, DD)
    or None if the date format is invalid
    */

    if (dateStr.isEmpty()) {
        return QDate();
    }

    QString paddedDate = dateStr;
    if (dateStr.length() % 2 != 0) {
        paddedDate.prepend("0"); // Agregar un 0 inicial si la longitud es impar
    }

    // Intentar con diferentes formatos según la longitud
    if (paddedDate.length() == 8) {
        return QDate::fromString(paddedDate, "ddMMyyyy");
    } else if (paddedDate.length() == 6) {
        QString yearPrefix = paddedDate.right(2).toInt() < 80 ? "20" : "19";
        return QDate::fromString(yearPrefix + paddedDate, "yyyyMMdd");
    } else if (paddedDate.length() == 4) {
        QString yearPrefix = paddedDate.right(2).toInt() < 80 ? "20" : "19";
        return QDate::fromString(yearPrefix + paddedDate, "yyyyMM");
    } else if (paddedDate.length() == 2) {
        QString yearPrefix = paddedDate.toInt() < 80 ? "20" : "19";
        return QDate::fromString(yearPrefix + paddedDate, "yyyy");
    }

    return QDate(); // Fecha inválida
}


void FIEBDC::parseRecord(const QString& record) {
    /*
    parseRecord(record, interface)

        record: the record line readed from the file whith the format:
            type|field|field|subfield\\subfield|...
        [a] nothing or "a"
        {a} zero or more #-#twice#-# "a"
        <a> one or more #-#twice#-# "a"
        Types: V C D Y M N T K L Q J G E X B F A
            V: Property and Version
                1- [File_Owner]
                2- Format_Version[\\DDMMYYYY]
                3- [Program_Generator]
                4- [Header]\\{Title\\}
                5- [Chaters_set]
                6- [Comment]
            C: Record:
                1- Code{\\Code}
                2- [Unit]
                3- [Summary]
                4- {Price\\}
                5- {Date\\}
                6- [Type]
            D or Y: DECOMPOSITION or ADD DECOMPOSITION
                1- Parent Code
                2- <Child Code\\ [Factor]\\ [Yield]>
            M or N: MEASURE or ADD MEASURE
                1- [Parent Code\\]Child Code
                2- {Path\}
                3- TOTAL MEASURE
                4- {Type\\Comment\\Unit\\Length\\Width\\Height\\}
                5- [Label]
            T: Text
                1- Code
                2- Description text
            K: Coefficients
                1- { DN \\ DD \\ DS \\ DR \\ DI \\ DP \\ DC \\ DM \\ DIVISA \\ }
                2-  CI \\ GG \\ BI \\ BAJA \\ IVA
                3- { DRC \\ DC \\ DRO \\ DFS \\ DRS \\ DFO \\ DUO \\ DI \\ DES \\ DN \\
                  DD \\ DS \\ DIVISA \\ }
                4- [ n ]
            L: Sheet of Conditions 1
                A)
                    1- Empty
                    2- {Section Code\\Section Title}
                B)
                    1- Record Code
                    2- {Section Code\\Section Text}
                    3- {Section Code\\RTF file}
                    4- {Section Code\\HTM file}
            Q: Sheet of Conditions 2
                1- Record Code
                2- {Section Code\\Paragraph key\\{Field key;}\\}|
            J: Sheet of Conditions 3
                1- Paragraph code
                2- [Paragraph text]
                3- [RTF file]
                4- [HTML file]
            G: Grafic info
                1- <grafic_file.ext\\>
            E: Company
                1- company Code
                2 [ summary ]
                3- [ name ]
                4- { [ type ] \\ [ subname ] \\ [ address ] \\ [ postal_code ]
                  \\ [ town ] \\ [ province ] \\ [ country ] \\ { phone; }
                  \\ { fax; }  \\ {contact_person; } \\ }
                5- [ cif ] \\ [ web ] \\ [ email ] \\
            X: Tecnical information
                A)
                    1- Empty
                    2- < TI_Code \\ TI_Descitption \\ TI_Unit >
                B)
                    1- Record_code
                    2- < TI_Code \\ TI_value >
            F: #-#Adjunto#-# File
                1- Record code
                2- { Type \\ { Filenames; } \\ [Description] }
            B: Change code
                1- Record Code
                2- New code
            A: Labels
                1- Record Code
                2- <Label\\>
            interface:
    */
    QStringList fields = record.split("|");
    if (fields.isEmpty()) {
        return;
    }

    QString recordType = fields.at(0);
    if (recordType == "V")
    {
    }
    else if (recordType == "C")
    {
    }
    else if (recordType == "D" || recordType == "Y")
    {
    }
    else if (recordType == "T")
    {
    } else {
        qDebug() << "Unknown record type:" << recordType << fields;
    }
}

void FIEBDC::parseV(QStringList fields)
{
    /*
    parseV(field_list)

    field_list: field list of the record
        0- V :Property and Version
        1- [File_Owner]
        2- Format_Version[\DDMMYYYY]
        3- [Program_Generator]
        4- [Header]\{Title\}
        5- [Chaters_set]
        6- [Comment]
        7- [Data type]
        8- [Number budget certificate]
        9- [Date budget certificate]
    */

    if (fields.size() < 10) {
        qWarning() << "Invalid 'V' record, insufficient fields:" << fields;
        return;
    }

    QString owner = fields[1].trimmed();
    QString versionDate = fields[2].trimmed();
    QString generator = fields[3].trimmed();
    QString headerTitle = fields[4].trimmed();
    QString characterSet = fields[5].trimmed();
    QString comment = fields[6].trimmed();
    QString dataType = fields[7].trimmed();
    QString numberCertificate = fields[8].trimmed();
    QString dateCertificate = fields[9].trimmed();

    // Process version and date
    QStringList versionDateParts = versionDate.split("\\");
    if (!versionDateParts.isEmpty()) {
        auto fileFormat = versionDateParts[0];
        qDebug() << "File format set to:" << fileFormat;

        if (versionDateParts.size() > 1) {
            QDate parsedDate = parseDate(versionDateParts[1]);
            if (parsedDate.isValid()) {
                qDebug() << "Parsed version date:" << parsedDate;
            }
        }
    }

    /*
    # _____number of fields_____
    # Any INFORMATION after last field separator is ignored
    if len(field_list) > 10:
        field_list = field_list[:10]
    # If there are no sufficient fields, the fields are added
    # with empty value:""
    else:
        field_list = field_list + [""]*(10-len(field_list))
    # control character are erased: end of line, tab, space
    # only leading and trailing whitespace in owner, generator, comment
    # _____Fields_____
    _record_type = self.delete_control_space(field_list[0])
    _owner = field_list[1].strip()
    _owner = self.delete_control(_owner)
    _version_date = self.delete_control_space(field_list[2])
    _generator = field_list[3].strip()
    _generator = self.delete_control(_generator)
    _header_title = field_list[4].strip()
    _header_title = self.delete_control(_header_title)
    _character_set = self.delete_control_space(field_list[5])
    _comment = field_list[6].strip("\t \n\r")
    _data_type = self.delete_control_space(field_list[7])
    _number_certificate = self.delete_control_space(field_list[8])
    __date_certificate = self.delete_control_space(field_list[9])
    # _____Owner_____
    self.__budget.setOwner(_owner)
    # _____Version-Date_____
    _version_date = _version_date.split("\\")
    _file_format = _version_date[0]
    if _file_format in self.__format_list:
        self.__file_format = _file_format
        _tuni = _("FIEBDC format: $1")
        _uni = utils.mapping(_tuni, (_file_format,))
        print(_uni)

    if len(_version_date) > 1:
        _date = _version_date[1]
        if _date != "":
            _parsed_date = self.parseDate(_date)
            if _parsed_date is not  None:
                self.__budget.setDate(_parsed_date)
    # _____Generator_____
    # ignored field
    _tuni = _("FIEBDC file generated by $1")
    _uni = utils.mapping(_tuni, (_generator,))
    print(_uni)
    # _____Header_Title_____
    _header_title = _header_title.split("\\")
    _header_title = [_title.strip() for _title in _header_title]
    _header = _header_title.pop(0)
    _title = [ ]
    for _title_index in _header_title:
        if _title_index != "":
            _title.append(_title_index)
    if _header != "":
        self.__budget.setTitleList([ _header, _title])
    # _____Characters_set_____
    # field parsed in readFile method
    # _____Comment_____
    if _comment != "":
        self.__budget.setComment(_comment)
    # _____Data type_____
    # 1 -> Base data.
    # 2 -> Budget.
    # 3 -> Budget certificate.
    # 4 -> Base date update.
    try:
        _data_type = int(_data_type)
    except ValueError:
        _data_type = ""
    if _data_type == 3:
        # _____Number budget certificate_____
        try:
            _number_certificate = int(_number_certificate)
        except ValueError:
            _number_certificate = ""
        # _____Date budget certificate_____
        if _date_certificate != "":
            _parsed_date_certificate = self.parseDate(_date_certificate)
            if _parsed_date_certificate is None:
                _date_certificate = ""
            else:
                _date_certificate = _parsed_date_certificate
        self.__budget.setBudgetype(_data_type)
        self.__budget.setCertificateOrder(_number_certificate)
        self.__budget.setCertificateDate(_parsed_date_cerfificate)
    elif _data_type != "":
        self.__budget.setBudgeType(_data_type)
    self.__statistics.valid = self.__statistics.valid + 1
    */
}

void FIEBDC::readFile(Budget* budget, QString filename) {
    // Implementación de la función para leer el archivo
    if (budget != nullptr) {
        __budget = budget;
    }
    if (!filename.isEmpty()) {
        __filename = filename;
    }
    // Lógica para leer el archivo
}