Creating Terraform-like configuration languages with HCL and Go

    // Find all Excel files in the input folder and its subfolders
    List<File> excelFiles = findExcelFiles(inputFolder);

    // Create the output folder for merged files
    String outputFolder = outputParentFolder + File.separator + "MergedOutput";
    File outputDirectory = new File(outputFolder);
    outputDirectory.mkdirs(); // Create the "MergedOutput" directory if it doesn't exist

    // Create subfolders for .xlsx and .csv files
    String xlsxSubfolder = outputFolder + File.separator + "XLSX";
    String csvSubfolder = outputFolder + File.separator + "CSV";
    File xlsxDirectory = new File(xlsxSubfolder);
    File csvDirectory = new File(csvSubfolder);
    xlsxDirectory.mkdirs();
    csvDirectory.mkdirs();

    // Merge Excel files
    Map<String, List<File>> groupedFiles = groupFilesByName(excelFiles);
    for (Map.Entry<String, ListFile>> entry : groupedFiles.entrySet()) {
        String outputFileName = entry.getKey();
        String xlsxFilePath = xlsxSubfolder + File.separator + outputFileName;
        String csvFilePath = csvSubfolder + File.separator + outputFileName.replace(".xlsx", ".csv");

        mergeExcelFiles(entry.getValue(), xlsxFilePath);
        convertXlsxToCsv(xlsxFilePath, csvFilePath);
    }
}

private static List<File> findExcelFiles(String folderPath) {
    List<File> excelFiles = new ArrayList<>();
    File inputFolder = new File(folderPath);
    File[] files = inputFolder.listFiles();

    if (files != null) {
        for (File file : files) {
            if (file.isDirectory()) {
                excelFiles.addAll(findExcelFiles(file.getPath()));
            } else if (file.getName().endsWith(".xlsx")) {
                excelFiles.add(file);
            }
        }
    }
    return excelFiles;
}

private static Map<String, ListFile>> groupFilesByName(List<File> files) {
    Map<String, ListFile>> groupedFiles = new HashMap<>();

    for (File file : files) {
        String fileName = file.getName();

        if (groupedFiles.containsKey(fileName)) {
            groupedFiles.get(fileName).add(file);
        } else {
            ListFile> fileList = new ArrayList<>();
            fileList.add(file);
            groupedFiles.put(fileName, fileList);
        }
    }

    return groupedFiles;
}

private static void mergeExcelFiles(List<File> files, String outputFolder) {
    try {
        Workbook mergedWorkbook = new XSSFWorkbook();
        for (File file : files) {
            FileInputStream fileInputStream = new FileInputStream(file);
            Workbook workbook = new XSSFWorkbook(fileInputStream);

            for (int i = 0; i < workbook.getNumberOfSheets(); i++) {
                Sheet sheet = workbook.getSheetAt(i);
                String sheetName = sheet.getSheetName();
                Sheet mergedSheet = mergedWorkbook.getSheet(sheetName);

                if (mergedSheet == null) {
                    mergedSheet = mergedWorkbook.createSheet(sheetName);
                }

                for (int j = 0; j < sheet.getPhysicalNumberOfRows(); j++) {
                    Row row = sheet.getRow(j);
                    if (row != null) { // Check if the row is not null
                        Row mergedRow = mergedSheet.createRow(mergedSheet.getLastRowNum() + 1);

                        for (int k = 0; k < row.getPhysicalNumberOfCells(); k++) {
                            Cell cell = row.getCell(k);
                            Cell mergedCell = mergedRow.createCell(k);

                            if (cell != null) {
                                CellType cellType = cell.getCellType();
                                switch (cellType) {
                                    case STRING:
                                        mergedCell.setCellValue(cell.getStringCellValue());
                                        break;
                                    case NUMERIC:
                                        if (DateUtil.isCellDateFormatted(cell)) {
                                            mergedCell.setCellValue(cell.getDateCellValue());
                                        } else {
                                            mergedCell.setCellValue(cell.getNumericCellValue());
                                        }
                                        break;
                                    // Handle other cell types as needed
                                    default:
                                        // Handle unknown or unsupported cell types
                                        break;
                                }
                            }
                        }
                    }
                }
            }
            fileInputStream.close();
        }

        // Save the merged workbook as .xlsx
        File outputFile = new File(outputFolder);
        FileOutputStream fileOutputStream = new FileOutputStream(outputFile);
        mergedWorkbook.write(fileOutputStream);
        fileOutputStream.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

private static void convertXlsxToCsv(String xlsxFile, String csvFile) {
    try {
        FileInputStream xlsxInputStream = new FileInputStream(xlsxFile);
        Workbook workbook = new XSSFWorkbook(xlsxInputStream);
        Sheet sheet = workbook.getSheetAt(0); // Assuming you want to convert the first sheet

        FileWriter csvWriter = new FileWriter(csvFile);

        for (int i = 0; i < sheet.getPhysicalNumberOfRows(); i++) {
            Row row = sheet.getRow(i);
            for (int j = 0; j < row.getPhysicalNumberOfCells(); j++) {
                Cell cell = row.getCell(j);
                if (j > 0) {
                    csvWriter.append(',');
                }
                if (cell != null) {
                    csvWriter.append(cell.toString());
                }
            }
            csvWriter.append('\n');
        }

        csvWriter.flush();
        csvWriter.close();
        xlsxInputStream.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}