/************************* PROJECT RON *************************/
/* Copyright (c) 2026 StuyPulse Robotics. All rights reserved. */
/* Use of this source code is governed by an MIT-style license */
/* that can be found in the repository LICENSE file.           */
/***************************************************************/
package tools.PathplannerSearch;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import tools.PathplannerSearch.Main.ARGUMENTS;
import tools.ToolClasses.ArgumentedTool;

import static tools.util.AnsiColors.*;

/**
 *
 *
 * <h2>Utility class that gives search features that Pathplanner lacks</h2>
 *
 * <p>
 * This class is meant to help search for where paths and linked variables are
 * used so you can
 * clean up unused ones.
 */
public final class PathplannerSearch extends ArgumentedTool<ARGUMENTS> {
    public enum SearchType {
        LINKED_WAYPOINT,
        PATH
    }

    public PathplannerSearch() {
        super(Main.ARGUMENTS.class);
    }

    /**
     *
     *
     * <h4>Functionality</h4>
     *
     * <p>
     * Searches through .path files in <code>src/main/deploy/pathplanner</code> and
     * logs files that
     * match a certain search term based on the search type.
     *
     * @param parsedArgs the parsed arguments
     */
    @Override
    protected void execute(Map<ARGUMENTS, Object> parsedArgs) {
        String searchTerm = ((String) parsedArgs.get(ARGUMENTS.SEARCH_TERM)).toLowerCase();
        SearchType searchType = ((SearchType) parsedArgs.get(ARGUMENTS.SEARCH_TYPE));

        switch (searchType) {
            case LINKED_WAYPOINT -> {
                final File[] files = new File("./src/main/deploy/pathplanner/paths/").listFiles();
                if (files == null)
                    break;

                final List<String> matches = new ArrayList<>();
                for (final File file : files) {
                    try {
                        final String content = Files.readString(file.toPath()).toLowerCase();
                        if (content.isBlank())
                            continue;
                        if (content.contains("\"linkedname\"") && content.contains("\"" + searchTerm + "\"")) {
                            final String folderName = parseFolderKeyFromFileContent(content);
                            matches.add(folderName + "/" + file.getName());
                        }
                    } catch (IOException e) {
                        System.out.println("Error reading file: " + file.getName());
                        e.printStackTrace();
                    }
                }

                logFiles(searchTerm, searchType, matches);
            }
            case PATH -> {
                final File[] files = new File("./src/main/deploy/pathplanner/autos/").listFiles();
                if (files == null)
                    break;

                final List<String> matches = new ArrayList<>();
                for (final File file : files) {
                    try {
                        final String content = Files.readString(file.toPath()).toLowerCase();
                        if (!content.contains("\"sequential\""))
                            continue;
                        if (content.contains("\"path\"")
                                && content.contains("\"pathname\"")
                                && content.contains("\"" + searchTerm + "\"")) {

                            final String folderName = parseFolderKeyFromFileContent(content);
                            matches.add(folderName + "/" + file.getName());
                        }
                    } catch (IOException e) {
                        System.out.println("Error reading file: " + file.getName());
                        e.printStackTrace();
                    }
                }

                logFiles(searchTerm, searchType, matches);
            }
            default -> {
                System.out.println("Specify a valid search type by editing the file.");
                System.exit(1);
            }
        }
    }

    /**
     * Parses the "folder" key from the content of a .path file.
     *
     * <p>
     * As Java doesn't have a built in JSON parser and for only having to do this
     * once, it would be
     * overkill to add a dependency.
     *
     * <p>
     * This method uses regex to parse the "folder" key from the .path file.
     * <code>.path</code>
     * files are essentially just JSON files but with a different extension.
     *
     * @param content the content of the .path file
     * @return the value of the "folder" key in the .path file, or an empty string
     *         if it doesn't exist
     */
    public static String parseFolderKeyFromFileContent(String content) {
        final String folderName;
        Pattern regex = Pattern.compile(
                "\"folder\"\\s*:\\s*\"([^\"]*)\"",
                Pattern.CASE_INSENSITIVE); // ima be honest i used ai for this regex 🤤
        Matcher match = regex.matcher(content);
        if (match.find()) {
            folderName = match.group(1);
        } else {
            folderName = "";
        }

        return folderName;
    }

    /**
     * Logs the result of the search to the console with some formatting.
     *
     * <p>
     * Uses ANSI color codes for coloring the output.
     *
     * <p>
     * If no matches are found, it will log "None were found." in red.
     *
     * <p>
     * Otherwise, it will log the list of matches in green on separate lines.
     *
     * <p>
     * <b>Example input and output:</b>
     *
     * <pre>
     * ./gradlew runPathPlannersearch -Pargs="disrupt path"
     * </pre>
     *
     * <pre>
     * Autons that use the path 'disrupt':
     * disrupt/LB Disrupt.auto
     * disrupt/LT Disrupt.auto
     * disrupt/RB Disrupt.auto
     * disrupt/RT Disrupt.auto
     * </pre>
     *
     * @param searchTerm
     * @param searchType
     * @param matches
     */
    public static void logFiles(String searchTerm, SearchType searchType, List<String> matches) {
        String stem = switch (searchType) {
            case LINKED_WAYPOINT -> "Paths that use the linked waypoint '";
            case PATH -> "Autons that use the path '";
            default -> "";
        };

        System.out.println(stem + YELLOW + searchTerm + "'" + RESET + ":");
        if (matches.isEmpty()) {
            System.out.println(RED + "None were found." + RESET);
            return;
        }

        for (String match : matches) {
            System.out.println(GREEN + match + RESET);
        }
    }
}