"use strict";

const twoAlphaPattern = /^[a-zA-z]{2,3}/;
const processOnlyB = /^[a-zA-z][0-9]{2,4}$/;
// const reactorNumberPattern = /^[0-9]{2}--/;
// const id = /[-]?([QP][0-9]{4,}|[0-9]{5,})[-]?/;
const normal = /^[0-9]{2}[.][0-9]{1}[.]?[0-9]{0,1}/;
const fileSystemSafe = /[\\,\/,\:,\*,\?,\"",\<,\>,\|]/;

const values = [
    { text: '', rds: '', psn: '', reactor: '', layer: '', zone: '', employee: '', lot: '' },
    { text: '12-123456-1234', rds: '123456', psn: '1234', reactor: '12', layer: '', zone: '', employee: '', lot: '' },
    { text: '12-1234567-1234', rds: '1234567', psn: '1234', reactor: '12', layer: '', zone: '', employee: '', lot: '' },
    { text: '12-12345678-1234', rds: '12345678', psn: '1234', reactor: '12', layer: '', zone: '', employee: '', lot: '' },
    { text: '123456', rds: '123456', psn: '', reactor: '', layer: '', zone: '', employee: '', lot: '' },
    { text: '1T123456', rds: '123456', psn: '', reactor: '', layer: '', zone: '', employee: '', lot: '' },
    { text: 'MP', rds: '', psn: '', reactor: '', layer: '', zone: '', employee: 'MP', lot: '' },
    { text: '12-123456-1234.2-1', rds: '123456', psn: '1234', reactor: '12', layer: '2', zone: '1', employee: '', lot: '' },
    { text: '12-1234567-1234.2-1', rds: '1234567', psn: '1234', reactor: '12', layer: '2', zone: '1', employee: '', lot: '' },
    { text: '12-12345678-1234.2-1', rds: '12345678', psn: '1234', reactor: '12', layer: '2', zone: '1', employee: '', lot: '' },
    { text: '12-123456-1234.02-1', rds: '123456', psn: '1234', reactor: '12', layer: '2', zone: '1', employee: '', lot: '' },
    { text: '12-1234567-1234.02-1', rds: '1234567', psn: '1234', reactor: '12', layer: '2', zone: '1', employee: '', lot: '' },
    { text: '12-12345678-1234.02-1', rds: '12345678', psn: '1234', reactor: '12', layer: '2', zone: '1', employee: '', lot: '' },
    { text: '20', rds: '', psn: '', reactor: '20', layer: '', zone: '', employee: '', lot: '' },
    { text: '20.2', rds: '', psn: '', reactor: '20', layer: '2', zone: '', employee: '', lot: '' },
    { text: '20.2.1', rds: '', psn: '', reactor: '20', layer: '2', zone: '1', employee: '', lot: '' },
    { text: '20.1.1', rds: '', psn: '', reactor: '20', layer: '1', zone: '1', employee: '', lot: '' },
    { text: 'P2-LOW-RR', rds: '', psn: 'RR', reactor: 'P2', layer: '', zone: '', employee: '', lot: '' },
    { text: 'i171308.1.51', rds: 'i171308.1.51', psn: '', reactor: '', layer: '', zone: '', employee: '', lot: '' },
    { text: 'o171308.1.51', rds: 'o171308.1.51', psn: '', reactor: '', layer: '', zone: '', employee: '', lot: '' },
    { text: 'O171308.1.51', rds: 'O171308.1.51', psn: '', reactor: '', layer: '', zone: '', employee: '', lot: '' },
    { text: '171308.1.51', rds: '171308.1.51', psn: '', reactor: '', layer: '', zone: '', employee: '', lot: '' },
    { text: '75-QP1414-SPLIT4', rds: '', psn: 'SPLIT4', reactor: '75', layer: '', zone: '', employee: '', lot: '' },
    { text: 'B48', rds: '', psn: '', reactor: '', layer: '', zone: '', employee: '', lot: 'B48' },
    { text: 'B48', rds: '', psn: '', reactor: '', layer: '', zone: '', employee: '', lot: 'B48' },
];

function tryParseInt(str, defaultValue) {
    const parsedValue = parseInt(str);
    return isNaN(parsedValue) ? defaultValue : parsedValue;
}

function getReactorAndRDS(defaultReactor, defaultRDS, text, formattedText, segments) {
    let result = {};
    let rds;
    let reactor;
    let rdsValue;
    if (text == null || text.length === 0 || segments.length === 0 || formattedText == null || formattedText.length === 0)
        reactor = defaultReactor;
    else
        reactor = segments[0];
    if (segments.length <= 1 || !tryParseInt(segments[1], false) || rdsValue < 99)
        rds = defaultRDS;
    else
        rds = segments[1];
    if (reactor.length > 3) {
        rds = reactor;
        reactor = defaultReactor;
    }
    result = { reactor: reactor, rds: rds };
    return result;
}

function getLayerAndPSN(defaultLayer, defaultPSN, segments) {
    let result = {};
    let psn;
    let layer;
    if (segments.length <= 2) {
        psn = defaultPSN;
        layer = defaultLayer;
    }
    else {
        let segmentsB = segments[2].split('.');
        psn = segmentsB[0];
        if (segmentsB.length <= 1)
            layer = defaultLayer;
        else {
            layer = segmentsB[1];
            if (layer.length > 1 && layer[0] === '0')
                layer = layer.substring(1);
        }
    }
    result = { layer: layer, psn: psn };
    return result;
}

function getZone(segments) {
    let result = '';
    if (segments.length <= 3)
        result = '';
    else {
        result = segments[3];
        if (result.length > 1 && result[0] === '0')
            result = result.substring(1);
    }
    return result;
}

function getValue(text) {
    let result = {};
    let lot = '';
    let psn = '';
    let rds = '';
    let zone = '';
    let layer = '';
    let reactor = '';
    let employee = '';
    let defaultPSN = '';
    let defaultRDS = '';
    let defaultZone = '';
    let defaultLayer = '';
    let defaultReactor = '';
    let defaultEmployee = '';
    if (text.match(processOnlyB)) {
        lot = text.toUpperCase();
        psn = defaultPSN;
        rds = defaultRDS;
        zone = defaultZone;
        layer = defaultLayer;
        reactor = defaultReactor;
        employee = defaultEmployee;
    }
    else if (text == null || text.length === 0 || (text.length == 2 && text.match(twoAlphaPattern))) {
        lot = text;
        employee = lot;
        psn = defaultPSN;
        rds = defaultRDS;
        zone = defaultZone;
        layer = defaultLayer;
        reactor = defaultReactor;
    }
    else if (text.match(normal)) {
        let segments = text.split('.');
        lot = text;
        psn = defaultPSN;
        rds = defaultRDS;
        layer = segments[1];
        reactor = segments[0];
        employee = defaultEmployee;
        if (segments.length <= 2)
            zone = defaultZone;
        else
            zone = segments[2];
    }
    else {
        // Remove illegal characters \/:*?"<>| found in the Lot.
        lot = text.replace(fileSystemSafe, "_").split('\r')[0].split('\n')[0];
        if (lot.length > 2 && lot[0] == '1' && (lot[1] == 'T' || lot[1] == 't'))
            lot = lot.substring(2);
        let segments = lot.split('-');
        // let hasRDS = lot.match(id);
        let reactorAndRDS = getReactorAndRDS(defaultReactor, defaultRDS, text, lot, segments);
        reactor = reactorAndRDS.reactor;
        rds = reactorAndRDS.rds;
        let layerAndPSN = getLayerAndPSN(defaultLayer, defaultPSN, segments);
        layer = layerAndPSN.layer;
        psn = layerAndPSN.psn;
        zone = getZone(segments);
        if (segments.length <= 4)
            employee = defaultEmployee;
        else
            employee = segments[4];
    }
    result = { rds: rds, psn: psn, reactor: reactor, layer: layer, zone: zone, employee: employee, lot: lot };
    return result;
};

values.forEach(element => {
    let value = getValue(element.text);
    if (value.rds !== element.rds)
        console.error("RDS doesn't match!");
    else if (value.psn !== element.psn)
        console.error("PSN doesn't match!");
    else if (value.reactor !== element.reactor)
        console.error("Reactor doesn't match!");
    else if (value.layer !== element.layer)
        console.error("Layer doesn't match!");
    else if (value.zone !== element.zone)
        console.error("Zone doesn't match!");
    else if (value.employee !== element.employee)
        console.error("Employee doesn't match!");
    else if (value.lot !== element.lot)
        console.error("Lot doesn't match!");
    else
        console.info('Match');
});