csv_processor.bal

import ballerina/mime;
import ballerina/http;
import ballerina/io;
import ballerina/time;
import ballerina/regex;

function handleCSVBodyParts(http:Request request) returns string[][]|error {
    var bodyParts = request.getBodyParts();
    if (bodyParts is mime:Entity[]) {
        string[][] csvLines = [];
        foreach var bodyPart in bodyParts {
            var mediaType = mime:getMediaType(bodyPart.getContentType());
            if (mediaType is mime:MediaType) {
                string baseType = mediaType.getBaseType();
                if ("text/csv" == baseType) {
                    byte[] payload = check bodyPart.getByteArray();
                    csvLines = check getCSVData(payload);
                } else {
                    return error("Invalid base type, not text/csv");
                }
            } else {
                return error("Invalid media type");
            }
        }
        return csvLines;
    } else {
        return error("Error in decoding multiparts!");
    }
}

function getCSVData(byte[] payload) returns string[][]|error {
    io:ReadableByteChannel readableByteChannel = check io:createReadableChannel(payload);
    io:ReadableCharacterChannel readableCharacterChannel = new (readableByteChannel, "UTF-8");
    io:ReadableCSVChannel readableCSVChannel = new io:ReadableCSVChannel(readableCharacterChannel, ",", 1);
    return check channelReadCsv(readableCSVChannel);
}

function channelReadCsv(io:ReadableCSVChannel readableCSVChannel) returns string[][]|error {
    string[][] results = [];
    int i = 0;
    while readableCSVChannel.hasNext() {
        var records = readableCSVChannel.getNext();
        if records is string[] {
            results[i] = records;
            i += 1;
        } else if records is error {
            check readableCSVChannel.close();
            return records;
        }
    }
    check readableCSVChannel.close();
    return results;
}

function readMedicalNeedsCSVLine(string[] line, int csvLineNo) returns [string, int, string, string, string, string, string, string, int]|error => [
    line[0],
    check readIntCSVField(line[1], csvLineNo),
    line[2],
    line[3],
    line[4],
    line[5],
    line[6],
    line[7],
    check readIntCSVField(line[8], csvLineNo)
];

function readSupplyQuotationsCSVLine(string[] line, int csvLineNo) returns [string, string, string, string, string, string, int, int, string, decimal]|error => [
    line[0],
    line[1],
    line[2],
    line[5],
    line[6],
    line[7],
    check readIntCSVField(line[8], csvLineNo),
    check readIntCSVField(line[8], csvLineNo),
    line[9],
    check readDollerCSVField(line[10], csvLineNo)
];

function readIntCSVField(string value, int csvLineNo) returns int|error {
    int|error intVal = int:fromString(value.trim());
    if (intVal is error) {
        return error(string `Check line ${csvLineNo}, Unable to convert the value "${value}" to integer!`);
    }
    return intVal;
}

function readDollerCSVField(string value, int csvLineNo) returns decimal|error {
    decimal|error decimalVal = decimal:fromString(value.substring(1, value.length()).trim());
    if (decimalVal is error) {
        return error(string `Check line ${csvLineNo}, Unable to convert doller amount:${value}`);
    }
    return decimalVal;
}

function getPeriod(string period) returns time:Date|error {
    string[] dateParts = regex:split(period, " ");
    int year = check int:fromString(dateParts[1]);
    int month = check getMonth(dateParts[0]);
    time:Date date = {year: year, month: month, day: 1};
    return date;
}

function getMonth(string month) returns int|error {
    match month {
        "Jan" => {
            return 1;
        }
        "Feb" => {
            return 2;
        }
        "Mar" => {
            return 3;
        }
        "Apr" => {
            return 4;
        }
        "May" => {
            return 5;
        }
        "Jun" => {
            return 6;
        }
        "Jul" => {
            return 7;
        }
        "Aug" => {
            return 8;
        }
        "Sep" => {
            return 9;
        }
        "Oct" => {
            return 10;
        }
        "Nov" => {
            return 11;
        }
        "Dec" => {
            return 12;
        }
        _ => {
            return error("Invalid month in the Period");
        }
    }
}

function getDateFromString(string dateString) returns time:Date|error {
    string[] dateParts = regex:split(dateString, "/");
    time:Date date = {
        year: check int:fromString(dateParts[2]),
        month: check int:fromString(dateParts[1]),
        day: check int:fromString(dateParts[0])
    };
    return date;
}

function createMedicalNeedsFromCSVData(string[][] inputCSVData) returns MedicalNeed[]|error {
    MedicalNeed[] medicalNeeds = [];
    string errorMessages = "";
    int csvLineNo = 0;
    foreach var line in inputCSVData {
        boolean hasError = false;
        int medicalItemId = -1;
        int medicalBeneficiaryId = -1;
        csvLineNo += 1;
        if (csvLineNo == 1) {
            continue; // Medical needs csv has empty line at the beginning, skipping it.
        }
        if (line.length() == 9) {
            var [_, _, urgency, period, beneficiary, itemName, itemType, unit, neededQuantity] = check readMedicalNeedsCSVLine(line, csvLineNo);
            int|error itemID = createOrRetrieveMedicalItem(itemName, itemType, unit);
            if itemID is error {
                errorMessages = errorMessages + string `Line:${csvLineNo}| Error occurred while inserting ${itemName} into MEDICAL_ITEM table`;
                hasError = true;
            } else {
                medicalItemId = itemID;
            }
            int|error beneficiaryID = getBeneficiaryId(beneficiary);
            if (beneficiaryID is error) {
                errorMessages = errorMessages + string `Line:${csvLineNo}| ${beneficiary} is missing in BENEFICIARY table`;
                hasError = true;
            } else {
                medicalBeneficiaryId = beneficiaryID;
            }
            if (!hasError) {
                MedicalNeed medicalNeed = {
                    itemID: medicalItemId,
                    beneficiaryID: medicalBeneficiaryId,
                    period: check getPeriod(period),
                    urgency,
                    neededQuantity
                };
                medicalNeeds.push(medicalNeed);
            }
        } else {
            return error(string `Invalid CSV Length in line:${csvLineNo}`);
        }
    }
    if (errorMessages.length() > 0) {
        return error(errorMessages);
    }
    return medicalNeeds;
}

function createOrRetrieveMedicalItem(string itemName, string itemType, string unit) returns int|error {
    int|error itemID = getMedicalItemId(itemName);
    if itemID is int {
        return itemID;
    }
    return addMedicalItemId(itemName, itemType, unit);
}

function createQuotationFromCSVData(string[][] inputCSVData) returns Quotation[]|error {
    Quotation[] qutoations = [];
    string errorMessages = "";
    int csvLineNo = 0;
    foreach var line in inputCSVData {
        boolean hasError = false;
        int medicalItemId = -1;
        int quotationSupplierId = -1;
        csvLineNo += 1;
        if line.length() == 11 {
            var [_, supplier, itemNeeded, regulatoryInfo, brandName, period, availableQuantity, remainingQuantity, expiryDate, unitPrice]
                = check readSupplyQuotationsCSVLine(line, csvLineNo);
            int|error itemID = getMedicalItemId(itemNeeded);
            if (itemID is error) {
                errorMessages = errorMessages + string `Line:${csvLineNo}| ${itemNeeded} is missing in MEDICAL_ITEM table`;
                hasError = true;
            } else {
                medicalItemId = itemID;
            }
            int|error supplierID = getSupplierId(supplier);
            if (supplierID is error) {
                errorMessages = errorMessages + string `Line:${csvLineNo}| ${supplier} is missing in SUPPLIER table`;
                hasError = true;
            } else {
                quotationSupplierId = supplierID;
            }
            if (!hasError) {
                Quotation quotation = {
                    supplierID: quotationSupplierId,
                    itemID: medicalItemId,
                    brandName,
                    availableQuantity,
                    remainingQuantity,
                    period: check getPeriod(period),
                    expiryDate: check getDateFromString(expiryDate),
                    regulatoryInfo,
                    unitPrice
                };
                qutoations.push(quotation);
            }
        }
        else {
            return error(string `Invalid CSV Length in line:${csvLineNo}`);
        }
    }
    if (errorMessages.length() > 0) {
        return error(errorMessages);
    }
    return qutoations;
}

isolated function createSupplierFromCSVData(string[][] inputCsv) returns Supplier[]|error {
    Supplier[] suppliers = [];
    string[] errors = [];
    foreach [int, string[]] [idx, line] in inputCsv.enumerate() {
        int csvLineNo = idx + 1;
        if line.length() != 4 {
            return error(string `Invalid CSV Length in line:${csvLineNo}`);
        }
        var [name, shortName, email, phoneNumber] = readSupplierCsvLine(line);
        boolean hasErrors = false;
        if !isValidEmail(email) {
            errors.push(string `Line:${csvLineNo}| provided email [${email}] is invalid`);
            hasErrors = true;
        }
        phoneNumber = regex:replaceAll(phoneNumber, "\\s+", "");
        if !isValidPhoneNumber(phoneNumber) {
            errors.push(string `Line:${csvLineNo}| provided phone number [${phoneNumber}] is invalid`);
            hasErrors = true;
        }
        if !hasErrors {
            Supplier supplier = {
                name: name,
                shortName: shortName,
                email: email,
                phoneNumber: phoneNumber
            };
            suppliers.push(supplier);
        }
    }
    if errors.length() > 0 {
        string errorMsg = string:'join(",", ...errors);
        return error (errorMsg);
    }
    return suppliers;
}

isolated function readSupplierCsvLine(string[] line) returns string[4] => [line[0], line[1], line[2], line[3]];

final string emailRegex = "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$";

isolated function isValidEmail(string email) returns boolean {
    return regex:matches(email, emailRegex);
}

final string phoneNumberRegex = "\\+[1-9]{1}[0-9]{3,14}";

isolated function isValidPhoneNumber(string phoneNumber) returns boolean {
    return regex:matches(phoneNumber, phoneNumberRegex);
}