import { tools } from "./plata-create-tools";
import { Command } from 'commander'
import path from 'node:path'

const program = new Command()

program.name('Plata Create cli')
program.description('CLI usada para criar rotas, libs, models e muito mais na plata')
program.version(Plata.PlataJson.version)

program.command('route <routes...>')
    .description('Cria uma rota utilizando o templete da plata')
    .action(async routes => {
        if (!Array.isArray(routes)) {
            return
        }

        const promises: any[] = []
        const plataName = Plata.ProjectJson.plata_name

        for (const route of routes) {
            const r = `${route}/`.replace(/:(.*?)(?:\/|$)/g, (_, parm) => {
                return parm[parm.length - 1] !== '?' ? `{${parm}}/` : `[${parm.slice(0, -1)}]/`
            })

            const routeArg = r.slice(0, -1).split('/')

            const routeFileName = routeArg[routeArg.length - 1] === '' ? 'index' : routeArg.pop()
            const routeFilePath = path.join('routes', ...routeArg.filter(v => v !== ''))

            promises.push(tools.files.deployFileToProject(
                routeFilePath,
                'route',
                `${routeFileName}.ts`,
                { PlataName: `${plataName}` }
            ).finally(() => console.log(
                `Rota ${routeFilePath}/${routeFileName === 'index' ? '' : routeFileName} criada`
            )))
        }

        await Promise.all(promises)
    })
;

program.command('lib <libs...>')
    .description('Cria uma lib utilizando o templete da plata')
    .action(async libs => {
        if (!Array.isArray(libs)) {
            return
        }

        const promises: any[] = []
        
        for (const lib of libs) {
            promises.push(tools.files.deployFileToProject(
                'libs',
                'lib',
                `${lib}.ts`.toLowerCase(),
                { Name: `${lib}`, name: `${lib}`.toLowerCase() }
            ).finally(() => console.log(`Config ${lib} criada`)))
        }

        await Promise.all(promises)

    })
;


program.command('class <classes...>')
    .description('Cria uma config com e uma clase utilizando o templete da plata')
    .action(async clazzs => {
        if (!Array.isArray(clazzs)) {
            return
        }

        const promises: any[] = []
        
        for (const lib of clazzs) {
            promises.push(tools.files.deployFileToProject(
                'configs',
                'config',
                `${lib}.ts`.toLowerCase(),
                { Name: `${lib}`, name: `${lib}`.toLowerCase() }
            ).finally(() => console.log(`Config ${lib} criada`)))

            promises.push(tools.files.deployFileToProject(
                'libs',
                'class',
                `${lib}.ts`.toLowerCase(),
                { Name: `${lib}`, name: `${lib}`.toLowerCase() }
            ).finally(() => console.log(`Classe ${lib} criada`)))
        }

        await Promise.all(promises)
    })
;

program.command('config <configs...>')
    .description('Cria uma config utilizando o templete da plata')
    .action(async configs => {
        if (!Array.isArray(configs)) {
            return
        }

        const promises: any[] = []
        
        for (const config of configs) {
            promises.push(tools.files.deployFileToProject(
                'configs',
                'config',
                `${config}.ts`.toLowerCase(),
                { Name: `${config}`, name: `${config}`.toLowerCase() }
            ).finally(() => console.log(`Config ${config} criada`)))
        }

        await Promise.all(promises)

    })
;

program.command('model <models...>')
    .description('Cria um model utilizando o templete da plata')
    .action(async models => {
        if (!Array.isArray(models)) {
            return
        }

        const promises: any[] = []
        const plataName = Plata.ProjectJson.plata_name

        for (const model of models) {
            promises.push(tools.files.deployFileToProject(
                'models',
                'model',
                `${model}.ts`.toLowerCase(),
                { Name: `${model}`, PlataName: `${plataName}` }
            ).finally(() => console.log(`Model ${model} criada`)))
        }

        await Promise.all(promises)
    })
;

program.command('task <tasks...>')
    .description('Cria uma task utilizando o templete da plata')
    .action(async tasks => {
        if (!Array.isArray(tasks)) {
            return
        }

        const promises: any[] = []
        const plataName = Plata.ProjectJson.plata_name

        for (const task of tasks) {
            promises.push(tools.files.deployFileToProject(
                'tasks',
                'task',
                `${task}.ts`.toLowerCase(),
                { Name: `${task}`, PlataName: `${plataName}` }
            ).finally(() => console.log(`Task ${tasks} criada`)))
        }

        await Promise.all(promises)
    })
;

program.command('cluster <clusters...>')
    .description('Cria o arquivo do worker utilizando o templete da plata')
    .action(async clusters => {
        if (!Array.isArray(clusters)) return

        const promises: any[] = []
        const plataName = Plata.ProjectJson.plata_name

        for (const cluster of clusters) {
            promises.push(tools.files.deployFileToProject(
                'clusters',
                'cluster',
                `${cluster}.ts`.toLowerCase(),
                { Name: `${cluster}`, name: `${cluster}`.toLowerCase(), PlataName: `${plataName}` }
            ).finally(() => console.log(`Worker ${cluster} criada`)))
        }
    })
;

program.command('cmd <cmds...>')
    .description('Cria o arquivo de um comando cmd')
    .action(async cmds => {
        if (!Array.isArray(cmds)) return

        for (const cmd of cmds) {
            await tools.files.deployFileToProject(
                'cmds',
                'cmd',
                `${cmd}.ts`.toLowerCase(),
                {}
            ).finally(() => console.log(`Cmd ${cmd} criado`))

            Plata.ProjectJson['my-scripts'] = Plata.ProjectJson['my-scripts'] ?? Object.create(null)

            if (Plata.ProjectJson['my-scripts'][`cmd:${cmd}`] === undefined) {
                Plata.ProjectJson['my-scripts'][`cmd:${cmd}`] = `plata-runtime + plata-cmd ${cmd}`
            }

            Plata.ProjectJson.scripts = JSON.parse(JSON.stringify({
                ...Plata.ProjectJson['my-scripts'],
                ...Plata.ProjectJson.scripts,
            }))

            await Plata.files.fs
                .writeFile(
                    path.join(Plata.ProjectDir, 'package.json'),
                    JSON.stringify(Plata.ProjectJson, null, 4)
                )
            ;
        }
    })

export const cli = program