index.js

const fs = require("fs");
const path = require("path");
const {  OpenAI } = require("openai");


const organization = '';
const project = '';
const openai = new OpenAI({
    organization,
    project,
    apiKey: ""
});

async function translateWithChatGPT(text, targetLanguage) {
    try {
        const response = await openai.chat.completions.create({
            model: "gpt-4o",
            messages: [
                {
                    role: "system",
                    content: "Você é um tradutor especializado. Retorne apenas o texto traduzido sem informações adicionais."
                },
                {
                    role: "user",
                    content: `Translate the text to ${targetLanguage.toLowerCase() === 'ar' ? 'Arabic' : targetLanguage}: ${text}`
                }
            ],
        });
        console.log(response.choices)
        return response.choices[0].message.content.trim().replaceAll('"', '')
    } catch (error) {
        console.error("Erro na tradução com ChatGPT:", error.message);
        throw error;
    }
}

async function updateI18nFiles(dirPath, labelName, enValue) {
    const failedTranslations = []; 
  
    try {
        if (!fs.existsSync(dirPath)) {
            console.error("Diretório não encontrado.");
            return;
        }
  
        const files = fs.readdirSync(dirPath).filter(file => file.endsWith(".json"));
  
        if (files.length === 0) {
            console.error("Nenhum arquivo JSON encontrado no diretório.");
            return;
        }
  
        for (const file of files) {
            const filePath = path.join(dirPath, file);
  
            const language = path.basename(file, ".json");
  
            const rawContent = fs.readFileSync(filePath, "utf-8");
            const fileContent = rawContent.trim() ? JSON.parse(rawContent) : null;
  
            if (!fileContent || Object.keys(fileContent).length === 0) {
                console.log(`Arquivo vazio ou sem conteúdo relevante: ${file}`);
                continue;
            }
  
            if (fileContent[labelName]) {
              console.log(`A label "${labelName}" já existe em ${file}. Atualizando valor.`);
              
              try {
                  const translatedValue =
                      language === "en"
                          ? enValue
                          : await translateWithChatGPT(enValue, language);
          
                  fileContent[labelName] = translatedValue;
          
                  fs.writeFileSync(filePath, JSON.stringify(fileContent, null, 2));
                  console.log(`Atualizado valor da label "${labelName}" em ${file}`);
              } catch (translateError) {
                  console.error(`Falha ao traduzir e atualizar para ${language} no arquivo ${file}:, translateError.message`);
                  failedTranslations.push(file);
              }
          
              continue;
          }
            try {
                const translatedValue =
                language === "en"
                    ? enValue
                    : await translateWithChatGPT(enValue, language);

                const entries = Object.entries(fileContent);
  
                const insertIndex = entries.findIndex(([key]) => key.localeCompare(labelName) > 0);
  
                if (insertIndex !== -1) {
                    entries.splice(insertIndex, 0, [labelName, translatedValue]);
                } else {
                    entries.push([labelName, translatedValue]);
                }
  
                const sortedContent = Object.fromEntries(entries);
  
                fs.writeFileSync(filePath, JSON.stringify(sortedContent, null, 2));
                console.log(`Adicionada label "${labelName}" em ${file}`);
            } catch (translateError) {
                console.error(`Falha ao traduzir para ${language} no arquivo ${file}:, ${translateError}`);
                failedTranslations.push(file);
            }
        }
  
        
        if (failedTranslations.length > 0) {
            console.log("\nArquivos com falha na tradução:");
            failedTranslations.forEach(file => console.log(`- ${file}`));
        }
    } catch (error) {
        console.error("Erro ao processar os arquivos:", error);
    }
}

  async function removeI18nLabel(dirPath, labelName) {
    try {
        if (!fs.existsSync(dirPath)) {
            console.error("Diretório não encontrado.");
            return;
        }

        const files = fs.readdirSync(dirPath).filter(file => file.endsWith(".json"));

        if (files.length === 0) {
            console.error("Nenhum arquivo JSON encontrado no diretório.");
            return;
        }

        for (const file of files) {
            const filePath = path.join(dirPath, file);

            const rawContent = fs.readFileSync(filePath, "utf-8");
            const fileContent = rawContent.trim() ? JSON.parse(rawContent) : null;

            if (!fileContent || Object.keys(fileContent).length === 0) {
                console.log(`Arquivo vazio ou sem conteúdo relevante: ${file}`);
                continue;
            }

            if (fileContent[labelName]) {
                delete fileContent[labelName];
                fs.writeFileSync(filePath, JSON.stringify(fileContent, null, 2));
                console.log(`Label "${labelName}" removida do arquivo ${file}`);
            } else {
                console.log(`Label "${labelName}" não encontrada no arquivo ${file}`);
            }
        }
    } catch (error) {
        console.error("Erro ao remover a label:", error);
    }
}


async function changeToCamelCase(dirPath, labelName) {
    const failedTranslations = []; 
  
    try {
        if (!fs.existsSync(dirPath)) {
            console.error("Diretório não encontrado.");
            return;
        }
  
        const files = fs.readdirSync(dirPath).filter(file => file.endsWith(".json"));
  
        if (files.length === 0) {
            console.error("Nenhum arquivo JSON encontrado no diretório.");
            return;
        }
  
        for (const file of files) {
            const filePath = path.join(dirPath, file);
  
            const language = path.basename(file, ".json").replace('-IN', '').replace('-SI', '');
  
            const rawContent = fs.readFileSync(filePath, "utf-8");
            const fileContent = rawContent.trim() ? JSON.parse(rawContent) : null;
  
            if (!fileContent || Object.keys(fileContent).length === 0) {
                console.log(`Arquivo vazio ou sem conteúdo relevante: ${file}`);
                continue;
            }
  
            if (fileContent[labelName]) {
              console.log(`A label "${labelName}" já existe em ${file}. Atualizando valor.`);
              
              try {
                
          
                  fileContent[labelName] = fileContent[labelName][0]+fileContent[labelName].slice(1).toLowerCase();
                
                  fs.writeFileSync(filePath, JSON.stringify(fileContent, null, 2));
                  console.log(`Atualizado valor da label "${labelName}" para ${fileContent[labelName][0]+fileContent[labelName].slice(1).toLowerCase()} em ${file}`);
              } catch (translateError) {
                  console.error(`Falha ao traduzir e atualizar para ${language} no arquivo ${file}:`, translateError.message);
                  failedTranslations.push(file);
              }
          
              continue;
          }
        }
    }catch(error){
        console.log(error)
    }
}

async function changeToUpperCase(dirPath, labelName) {
    const failedTranslations = []; 
  
    try {
        if (!fs.existsSync(dirPath)) {
            console.error("Diretório não encontrado.");
            return;
        }
  
        const files = fs.readdirSync(dirPath).filter(file => file.endsWith(".json"));
  
        if (files.length === 0) {
            console.error("Nenhum arquivo JSON encontrado no diretório.");
            return;
        }
  
        for (const file of files) {
            const filePath = path.join(dirPath, file);
  
            const language = path.basename(file, ".json").replace('-IN', '').replace('-SI', '');
  
            const rawContent = fs.readFileSync(filePath, "utf-8");
            const fileContent = rawContent.trim() ? JSON.parse(rawContent) : null;
  
            if (!fileContent || Object.keys(fileContent).length === 0) {
                console.log(`Arquivo vazio ou sem conteúdo relevante: ${file}`);
                continue;
            }
  
            if (fileContent[labelName]) {
              console.log(`A label "${labelName}" já existe em ${file}. Atualizando valor.`);
              
              try {
                
          
                  fileContent[labelName] = fileContent[labelName].toUpperCase();
                
                  fs.writeFileSync(filePath, JSON.stringify(fileContent, null, 2));
                  console.log(`Atualizado valor da label "${labelName}" para ${fileContent[labelName][0]+fileContent[labelName].slice(1).toLowerCase()} em ${file}`);
              } catch (translateError) {
                  console.error(`Falha ao traduzir e atualizar para ${language} no arquivo ${file}:`, translateError.message);
                  failedTranslations.push(file);
              }
          
              continue;
          }
        }
    }catch(error){
        console.log(error)
    }
}

// Uso do script
const dirPath = "/Users/otaviostasiak/Documents/rocketchat/Rocket.Chat.ReactNative/app/i18n/locales"; // Path for i18n folder
const labelName = ""; //  label name
const enValue = ""; // Valor in english

async function handleStart(flag) {
    switch (flag) {
        case 'camel':
            await changeToCamelCase(dirPath, labelName);
            break;
        case 'new':
            await updateI18nFiles(dirPath, labelName, enValue);
         break;
        case 'upper':
            await changeToUpperCase(dirPath, labelName);
        case 'delete':
            await removeI18nLabel(dirPath, labelName)
        default:
            console.log("Invalid flag. Use --camel or --new.");
    }
}

// Parse the command-line argument
const args = process.argv.slice(2); // Get arguments after "node script.js"
const flag = args[0]?.replace('--', ''); // Extract flag and remove "--" prefix

// Verify the flag and call the function
if (flag) {
    handleStart(flag);
} else {
    console.log("No flag provided. Use --camel or --new.");
}