//Remove unwanted string from xml data

/**
     * Remove unwanted data from the XML string
     * @param xmlString
     * @param regex
     * @return
     */
    public static String removeUnwantedData(String xmlString , String regex) {
        // Regex to match unwanted data that starts and ends with --
        // Compile the pattern
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(xmlString);
        // Replace matches with an empty string
        String cleanedString = matcher.replaceAll("");
        // Trim any extra whitespace
        return cleanedString.trim();
    }

//Read String XML List of data between the TAG  

/**
     * Extract data between specified tags
     *
     * @param xmlContent
     * @param tags
     * @param constructor
     * @param 
     * @return
     */
    public static  List extractDataBetweenTags(String xmlContent,
                                                     List tags,
                                                     Function<List, T> constructor) {
        List<List> extractedData = new ArrayList();
        // Extract data for each required tag
        for (String tag : tags) {
            extractedData.add(extractDataBetweenTag(xmlContent, tag));
        }

        // Determine the minimum size across all lists
        int minSize = extractedData.stream().map(List::size).min(Integer::compareTo).orElse(0);

        // Create objects using the extracted data
        List dataObjects = new ArrayList();
        for (int i = 0; i < minSize; i++) {
            List values = new ArrayList();
            for (List dataList : extractedData) {
                values.add(dataList.get(i).trim());
            }
            dataObjects.add(constructor.apply(values));
        }

        return dataObjects;
    }

// Read data based on condition. like if any id or requestId matched.

/**
     * Get data by reference
     * @param xmlList
     * @param reference1
     * @param reference2
     * @return
     */
   public static String getDataByReference(List xmlList, String reference1, String reference2) {
        String matchedData = null;
        try {
            for (String xmlString : xmlList) {
                List extractedData = extractDataBetweenTag(xmlString, reference2);
                if (reference1.equals(extractedData.get(0))) {
                    for (int i = 0; i < extractedData.size(); i++) {
                        matchedData = xmlString;
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return matchedData;
    }

// Write data multiple XML files based on the list..

/**
     * Helper method to create an XML file
     * @param data
     * @param outputFileName
     * @throws IOException
     */
    private static void createXMLFile(String data, String outputFileName) throws IOException {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(outputFileName))) {
            writer.write(data);
        }
    }

// Write CSV file based on the condition matched.

/**
     * Helper method to write a list of objects to a CSV file.
     * @param records  List of objects to be written to the file.
     * @param header   The header line for the CSV file.
     * @param fileName The name of the file to be created, including its path.
     * @throws IOException if an I/O error occurs.
     */
public static  void writeToCSV(List records, String header, String fileName) throws IOException {
        File file = new File(fileName);
        // Ensure the directory exists
        file.getParentFile().mkdirs();
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(file))) {
            // Write the header
            writer.write(header);
            writer.newLine();

            // Write each record to the CSV file
            for (T record : records) {
                StringBuilder data = new StringBuilder();
                Field[] fields = record.getClass().getDeclaredFields();

                for (Field field : fields) {
                    field.setAccessible(true); // Allow access to private fields
                    try {
                        Object value = field.get(record);
                        if (data.length() > 0) {
                            data.append(",");
                        }
                        // Handle null values and convert to String
                        data.append(value != null ? value.toString() : "");
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }

                writer.write(data.toString());
                writer.newLine();
            }
            System.out.println("File created successfully: " + file.getAbsolutePath());
        }
    }

// Helper method to read file content into a string.

/**
     * Helper method to read file content into a string
     * @param fileName
     * @return
     * @throws IOException
     */
    private static String readFileContent(String fileName) throws IOException {
        StringBuilder content = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            while ((line = reader.readLine()) != null) {
                content.append(line).append("\n");
            }
        }
        return content.toString();
    }

package com.infoqra.util;


import java.io.*;
import java.util.*;
import java.util.function.Function;
import java.util.regex.*;
import java.lang.reflect.Field;

/**
 * This class processes two XML files and generates multiple output files based on matches.
 *
 * @author Santosh Kushwah
 * @since 19-09-2024
 */
public class XMLProcessor {
    private static final String INPUT_FILE_NAME_1 = "FIRST_XML.xml";
    private static final String INPUT_FILE_NAME_2 = "SECOND_XML.xml";
    private static final String HEADERS = "ID,NAME,DOB,PHONE";
    private static final String FILE_FOLDER = "OUT/";
    private static final String FILE_NAME = FILE_FOLDER + "MASTER.csv";
    private static final String TAG_NAME = "request";
    private static final String TAG_2 = "reference_id";
    private static final String REGEX_FOR_UNWANTED_DATA = "--.*?--";

    public static void main(String[] args) {
        try {
            // Process the first XML file
            List everrors = processFirstXML(INPUT_FILE_NAME_1);
            // Process the second XML file and generate multiple output files based on matches
            processSecondXML(INPUT_FILE_NAME_2, everrors);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Process the first XML file and generate a CSV file
     *
     * @param inputFileName
     * @return
     * @throws IOException
     */
    private static List processFirstXML(String inputFileName) throws IOException {
        String xmlContent = readFileContent(inputFileName);
        List everrors = extractEVERRORData(xmlContent);
        writeToCSV(everrors, HEADERS, FILE_NAME);
        return everrors;
    }

    /**
     * Process the second XML file and generate multiple output files based on matches
     *
     * @param inputFileName
     * @param everrors
     * @throws IOException
     */
    private static void processSecondXML(String inputFileName, List everrors) throws IOException {
        String xmlContents = readFileContent(inputFileName);
        List extractedData = extractDataBetweenTag(xmlContents, TAG_NAME);

        List countCustId = new ArrayList();

        everrors.forEach(f -> {
            String matchedData = getDataByReference(extractedData, f.getPhone(), TAG_2);
            countCustId.add(f.getId());

            String fileName = f.getId() + "_" + f.getName();
            String outputFileName = FILE_FOLDER + "File-" + countCustId.size() + "-" + fileName;

            if (matchedData != null) {
                String cleanData = removeUnwantedData(matchedData, REGEX_FOR_UNWANTED_DATA);
                createOutputFile(cleanData, outputFileName);
            }
        });
    }

    /**
     * Create an output file
     *
     * @param cleanData
     * @param outputFileName
     */
    private static void createOutputFile(String cleanData, String outputFileName) {
        try {
            createXMLFile(cleanData, outputFileName);
        } catch (IOException e) {
            throw new RuntimeException("Error creating XML file: " + outputFileName, e);
        }
    }

    /**
     * Extract data between specified tags
     *
     * @param xmlContent
     * @return
     */
    public static List extractEVERRORData(String xmlContent) {
        List tags = List.of("ID", "NAME", "DOB", "PHONE");

        return extractDataBetweenTags(xmlContent, tags, values -> new UserData(
                values.get(0), // ID
                values.get(1), // NAME
                values.get(2), // DOB
                values.get(3) // PHONE
        ));
    }

    /**
     * Extract data between specified tags
     *
     * @param xmlContent
     * @param tags
     * @param constructor
     * @param 
     * @return
     */
    public static  List extractDataBetweenTags(String xmlContent,
                                                     List tags,
                                                     Function<List, T> constructor) {
        List<List> extractedData = new ArrayList();
        // Extract data for each required tag
        for (String tag : tags) {
            extractedData.add(extractDataBetweenTag(xmlContent, tag));
        }

        // Determine the minimum size across all lists
        int minSize = extractedData.stream().map(List::size).min(Integer::compareTo).orElse(0);

        // Create objects using the extracted data
        List dataObjects = new ArrayList();
        for (int i = 0; i < minSize; i++) {
            List values = new ArrayList();
            for (List dataList : extractedData) {
                values.add(dataList.get(i).trim());
            }
            dataObjects.add(constructor.apply(values));
        }

        return dataObjects;
    }
//Remove unwanted string from xml data

    /**
     * Remove unwanted data from the XML string
     *
     * @param xmlString
     * @param regex
     * @return
     */
    public static String removeUnwantedData(String xmlString, String regex) {
        // Regex to match unwanted data that starts and ends with --
        // Compile the pattern
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(xmlString);
        // Replace matches with an empty string
        String cleanedString = matcher.replaceAll("");
        // Trim any extra whitespace
        return cleanedString.trim();
    }


//Read String XML List of data between the TAG

    /**
     * Helper method to extract data between specified tags
     *
     * @param xmlContent
     * @param tagName
     * @return
     */
    private static List extractDataBetweenTag(String xmlContent, String tagName) {
        List extractedData = new ArrayList();
        String regex = "(.*?)"; // Regex to match the tag content
        Pattern pattern = Pattern.compile(regex, Pattern.DOTALL);
        Matcher matcher = pattern.matcher(xmlContent);
        while (matcher.find()) {
            extractedData.add(matcher.group(1).trim()); // Extracted data between the tags
        }
        return extractedData;
    }


// Read data based on condition. like if any id or requestId matched.

    /**
     * Get data by reference
     *
     * @param xmlList
     * @param reference1
     * @param reference2
     * @return
     */
    public static String getDataByReference(List xmlList, String reference1, String reference2) {
        String matchedData = null;
        try {
            for (String xmlString : xmlList) {
                List extractedData = extractDataBetweenTag(xmlString, reference2);
                if (reference1.equals(extractedData.get(0))) {
                    for (int i = 0; i < extractedData.size(); i++) {
                        matchedData = xmlString;
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return matchedData;
    }


// Write data multiple XML files based on the list..

    /**
     * Helper method to create an XML file
     *
     * @param data
     * @param outputFileName
     * @throws IOException
     */
    private static void createXMLFile(String data, String outputFileName) throws IOException {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(outputFileName))) {
            writer.write(data);
        }
    }


// Write CSV file based on the condition matched.

    /**
     * Helper method to write a list of objects to a CSV file.
     *
     * @param records  List of objects to be written to the file.
     * @param header   The header line for the CSV file.
     * @param fileName The name of the file to be created, including its path.
     * @throws IOException if an I/O error occurs.
     */
    public static  void writeToCSV(List records, String header, String fileName) throws IOException {
        File file = new File(fileName);
        // Ensure the directory exists
        file.getParentFile().mkdirs();
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(file))) {
            // Write the header
            writer.write(header);
            writer.newLine();

            // Write each record to the CSV file
            for (T record : records) {
                StringBuilder data = new StringBuilder();
                Field[] fields = record.getClass().getDeclaredFields();

                for (Field field : fields) {
                    field.setAccessible(true); // Allow access to private fields
                    try {
                        Object value = field.get(record);
                        if (data.length() > 0) {
                            data.append(",");
                        }
                        // Handle null values and convert to String
                        data.append(value != null ? value.toString() : "");
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    }
                }

                writer.write(data.toString());
                writer.newLine();
            }
            System.out.println("File created successfully: " + file.getAbsolutePath());
        }
    }


// Helper method to read file content into a string.

    /**
     * Helper method to read file content into a string
     *
     * @param fileName
     * @return
     * @throws IOException
     */
    private static String readFileContent(String fileName) throws IOException {
        StringBuilder content = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new FileReader(fileName))) {
            String line;
            while ((line = reader.readLine()) != null) {
                content.append(line).append("\n");
            }
        }
        return content.toString();
    }

    private static class UserData {
        private String id;
        private String name;
        private String dob;

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getDob() {
            return dob;
        }

        public void setDob(String dob) {
            this.dob = dob;
        }

        public String getPhone() {
            return phone;
        }

        public void setPhone(String phone) {
            this.phone = phone;
        }

        private String phone;

        public UserData(String id, String name, String dob, String phone) {
            this.id = id;
            this.name = name;
            this.dob = dob;
            this.phone = phone;
        }

        @Override
        public String toString() {
            return "UserData{" +
                    "id='" + id + '\'' +
                    ", name='" + name + '\'' +
                    ", dob='" + dob + '\'' +
                    ", phone='" + phone + '\'' +
                    '}';
        }
    }
}

// SECOND_XML.xml

   
    TD
    9999999999
    
ABX
    ABX
    743445


    TD
    7777777777
    
BBX
    ABX XYZ
    9889898


    TD
    8888888888
    
BBX
    ABX XYZ
    9889898



// FIRST_XML.xml
100
Santosh
02-10-1990
9999999999
101
Rahul
01-01-1990
8888888888
102
Mudit
12-12-1990
7777777777