/**
 * Here is where we take the raw definition provided by the consumer and and do any clean up and standardize the format of the
 * data that gets fed to the parser.
 */

import { CliCommandDefinition, CliCommandDefinitionArgument, CliCommandDefinitionOption } from '../types';

export const initCommandDefinitionOptions = (options: CliCommandDefinitionOption[]) => {
    options.forEach(o => {
        // strip leading dash from flag to be consistent
        if (o.flag) {
            o.flag = o.flag.replace(/-|\s/g, '');
        }
    });
};

export const initCommandDefinitionArgument = (arg: CliCommandDefinitionArgument): CliCommandDefinitionArgument => {
    // Default isOptional to true of a default value set  isOptional explicitly set to false (which should be a validation error)
    if (arg.default && arg.isOptional !== false) {
        arg.isOptional = true;
    }

    return arg;
};

export const initCommandDefinitionArguments = (
    args: CliCommandDefinitionArgument[]
): CliCommandDefinitionArgument[] => {
    args = args || [];

    return args.map(a => {
        return initCommandDefinitionArgument(a);
    });
};

// const parseArgSyntax = (cmdDef: CliCommandDefinition) => {

//     if (cmdDef.syntax) {

//         let cmd=[], rawArgs=[], rgx=/(\[|<)/;
//         // All non-([|<) are commands
//         cmdDef.syntax.split(/\s+/).forEach(x => {
//             (rgx.test(x.charAt(0)) ? rawArgs : cmd).push(x);
//         });

//         const cmdName = cmd.join(' ');
//         let parsedArgs: { name: string, required: boolean }[] = [];

//         if (rawArgs.length > 0) {

//             parsedArgs = rawArgs.map(arg => {

//                 const parseArg = (val: string, delims: string) => {
//                     if (val.charAt(0) === delims.charAt(0)) {
//                         if (!val.endsWith(delims.charAt(1))) {
//                             throw new Error(`Syntax Argument Error, expected '${delims.charAt(1)}'`);
//                         }
//                         return val.substr(1, val.length -2);
//                     }
//                     return null;
//                 }

//                 let parsedArg = parseArg(arg, '<>');
//                 const required = !!parsedArg;
//                 if (!required) {
//                     parsedArg = parseArg(arg, '[]');
//                 }

//                 return { name: parsedArg, required };

//             });

//         }
//         cmdDef.name = cmdName;
//         cmdDef.arguments = cmdDef.arguments || [];
//         parsedArgs.forEach(pa => {
//             const existingArg = cmdDef.arguments.find(a => a.name === pa.name);
//             if (existingArg) {
//                 existingArg.isOptional = !pa.required;
//             } else {
//                 cmdDef.arguments.push({ name: pa.name, isOptional: !pa.required })
//             }
//         })

//     }

// }

export const initCommandDefinition = (cmdDef: CliCommandDefinition): CliCommandDefinition => {
    cmdDef.options = cmdDef.options || [];
    initCommandDefinitionOptions(cmdDef.options);

    cmdDef.arguments = initCommandDefinitionArguments(cmdDef.arguments);

    return cmdDef;
};