import java.io.*;
import java.nio.file.*;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;
import java.util.regex.*;

/**
 * Tool to remove duplicate YAML test files based on MD5 hash of SQL content.
 *
 * This tool scans a directory recursively for YAML files, extracts the SQL
 * from the input section, calculates MD5 hash, and removes duplicates within
 * the same directory, keeping only one file per unique SQL.
 *
 * Usage: java removeDuplicateYamlTestFile <directory>
 */
public class removeDuplicateYamlTestFile {

    private static int totalFilesRemoved = 0;
    private static int totalFilesScanned = 0;

    public static void main(String[] args) {
        if (args.length < 1) {
            System.out.println("Usage: java removeDuplicateYamlTestFile <directory>");
            System.out.println("  <directory> - The directory to scan for YAML files");
            System.exit(1);
        }

        String directoryPath = args[0];
        File rootDir = new File(directoryPath);

        if (!rootDir.exists()) {
            System.err.println("Error: Directory does not exist: " + directoryPath);
            System.exit(1);
        }

        if (!rootDir.isDirectory()) {
            System.err.println("Error: Path is not a directory: " + directoryPath);
            System.exit(1);
        }

        System.out.println("Scanning directory: " + rootDir.getAbsolutePath());
        System.out.println();

        try {
            processDirectory(rootDir);
        } catch (Exception e) {
            System.err.println("Error processing directory: " + e.getMessage());
            e.printStackTrace();
            System.exit(1);
        }

        System.out.println();
        System.out.println("=== Summary ===");
        System.out.println("Total YAML files scanned: " + totalFilesScanned);
        System.out.println("Total duplicate files removed: " + totalFilesRemoved);
    }

    /**
     * Process all subdirectories recursively.
     * For each directory, find duplicates within that directory only.
     */
    private static void processDirectory(File dir) throws Exception {
        // First, collect all YAML files in this directory (not subdirectories)
        File[] yamlFiles = dir.listFiles((d, name) ->
            name.toLowerCase().endsWith(".yaml") || name.toLowerCase().endsWith(".yml"));

        if (yamlFiles != null && yamlFiles.length > 0) {
            processYamlFilesInDirectory(dir, yamlFiles);
        }

        // Then recursively process subdirectories
        File[] subdirs = dir.listFiles(File::isDirectory);
        if (subdirs != null) {
            for (File subdir : subdirs) {
                processDirectory(subdir);
            }
        }
    }

    /**
     * Process YAML files within a single directory, removing duplicates.
     */
    private static void processYamlFilesInDirectory(File dir, File[] yamlFiles) throws Exception {
        // Map: MD5 hash -> list of files with that hash
        Map<String, List<File>> md5ToFiles = new HashMap<>();

        for (File yamlFile : yamlFiles) {
            totalFilesScanned++;

            try {
                String sql = extractSqlFromYaml(yamlFile);
                if (sql == null || sql.trim().isEmpty()) {
                    // Skip files without SQL content
                    continue;
                }

                String md5 = calculateMD5(sql);
                md5ToFiles.computeIfAbsent(md5, k -> new ArrayList<>()).add(yamlFile);
            } catch (Exception e) {
                System.err.println("Warning: Could not process file: " + yamlFile.getName() + " - " + e.getMessage());
            }
        }

        // Remove duplicates (keep the first file, remove the rest)
        int removedInDir = 0;
        for (Map.Entry<String, List<File>> entry : md5ToFiles.entrySet()) {
            List<File> files = entry.getValue();
            if (files.size() > 1) {
                // Sort by filename to ensure consistent behavior
                files.sort(Comparator.comparing(File::getName));

                // Keep the first file, remove the rest
                File kept = files.get(0);
                for (int i = 1; i < files.size(); i++) {
                    File toRemove = files.get(i);
                    if (toRemove.delete()) {
                        System.out.println("Removed duplicate: " + toRemove.getAbsolutePath());
                        System.out.println("  (duplicate of: " + kept.getName() + ")");
                        removedInDir++;
                        totalFilesRemoved++;
                    } else {
                        System.err.println("Warning: Failed to delete file: " + toRemove.getAbsolutePath());
                    }
                }
            }
        }

        if (removedInDir > 0) {
            System.out.println("Removed " + removedInDir + " duplicate(s) in: " + dir.getAbsolutePath());
            System.out.println();
        }
    }

    /**
     * Extract SQL content from the input section of a YAML file.
     * Uses simple text parsing to handle the YAML structure.
     */
    private static String extractSqlFromYaml(File yamlFile) throws IOException {
        String content = new String(Files.readAllBytes(yamlFile.toPath()), "UTF-8");

        // Pattern to match the input.sql section
        // Handles both block scalar (|) and literal string formats

        // First, try to find "input:" section
        int inputIndex = content.indexOf("input:");
        if (inputIndex == -1) {
            return null;
        }

        String afterInput = content.substring(inputIndex + "input:".length());

        // Find "sql:" within the input section
        int sqlIndex = afterInput.indexOf("sql:");
        if (sqlIndex == -1) {
            return null;
        }

        String afterSql = afterInput.substring(sqlIndex + "sql:".length());

        // Determine if it's a block scalar (|) or inline
        String trimmed = afterSql.trim();

        if (trimmed.startsWith("|")) {
            // Block scalar - extract indented content
            return extractBlockScalar(afterSql);
        } else if (trimmed.startsWith("\"") || trimmed.startsWith("'")) {
            // Quoted string
            return extractQuotedString(trimmed);
        } else {
            // Could be inline or next line
            return extractInlineOrNextLine(afterSql);
        }
    }

    /**
     * Extract content from a YAML block scalar (|).
     */
    private static String extractBlockScalar(String content) {
        // Skip the | character and any modifiers
        int pipeIndex = content.indexOf('|');
        if (pipeIndex == -1) {
            return null;
        }

        String afterPipe = content.substring(pipeIndex + 1);

        // Find the first line break
        int firstNewline = afterPipe.indexOf('\n');
        if (firstNewline == -1) {
            return afterPipe.trim();
        }

        String blockContent = afterPipe.substring(firstNewline + 1);

        // Determine the indentation of the block content
        int baseIndent = 0;
        for (char c : blockContent.toCharArray()) {
            if (c == ' ') {
                baseIndent++;
            } else if (c == '\t') {
                baseIndent += 2; // Treat tab as 2 spaces
            } else {
                break;
            }
        }

        if (baseIndent == 0) {
            // No indentation found, might be empty or malformed
            return null;
        }

        // Extract all lines with the same or greater indentation
        StringBuilder result = new StringBuilder();
        String[] lines = blockContent.split("\n");

        for (String line : lines) {
            if (line.trim().isEmpty()) {
                result.append("\n");
                continue;
            }

            int lineIndent = 0;
            for (char c : line.toCharArray()) {
                if (c == ' ') {
                    lineIndent++;
                } else if (c == '\t') {
                    lineIndent += 2;
                } else {
                    break;
                }
            }

            if (lineIndent >= baseIndent) {
                // Part of the block
                if (line.length() > baseIndent) {
                    result.append(line.substring(baseIndent)).append("\n");
                } else {
                    result.append("\n");
                }
            } else if (!line.trim().isEmpty()) {
                // End of block (less indentation and non-empty)
                break;
            }
        }

        return result.toString().trim();
    }

    /**
     * Extract a quoted string value.
     */
    private static String extractQuotedString(String content) {
        char quote = content.charAt(0);
        int endQuote = content.indexOf(quote, 1);
        if (endQuote == -1) {
            return null;
        }
        return content.substring(1, endQuote);
    }

    /**
     * Extract inline value or value on next line.
     */
    private static String extractInlineOrNextLine(String content) {
        String[] lines = content.split("\n", 2);
        String firstLine = lines[0].trim();

        if (!firstLine.isEmpty()) {
            return firstLine;
        }

        if (lines.length > 1) {
            return extractBlockScalar("|" + lines[1]);
        }

        return null;
    }

    /**
     * Calculate MD5 hash of a string.
     */
    private static String calculateMD5(String input) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("MD5");

        // Normalize the SQL: trim whitespace and convert to lowercase for comparison
        String normalized = input.trim();

        byte[] digest = md.digest(normalized.getBytes());

        // Convert to hex string
        StringBuilder hexString = new StringBuilder();
        for (byte b : digest) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }

        return hexString.toString();
    }
}