/*
Copyright © 2025 Steven Carpenter <steven.carpenter@skdevstudios.com>

*/
package cmd

import (
    "fmt"
    "os"
    "io/fs"
    "path/filepath"
    "github.com/spf13/cobra"
    "strings"
    "strconv"
    "bufio"
    "regexp"
)

type Comment struct {
    FilePath     string
    LineNumber   int
    Priority     int
    Task         string
}

// rootCmd represents the base command when called without any subcommands
var rootCmd = &cobra.Command{
    Use:   "v2",
    Short: "Tooling to make dealing with TODO statements in comments easier to manage.",
    Long: `YUNODO redux is a better written version of a tool I wrote for internal use.
This application is a tool that takes comments that start with TODO: and outputs them in a given format.

format for comment is as follows:
    <COMMENT_SYMBOL>TODO: P<PRIORITY_VALUE> <COMMENT>

where COMMENT_SYMBOL is your languages comment symbol,
PRIORITY_VALUE is a priority from 0-9 where 9 is least critical and 0 is needs patched NOW!!!,
and PATH_TO_PROJECT is the path to your codebase's root.

Usage:
    yunodo -p <PATH_TO_PROJECT>

`,
    // Uncomment the following line if your bare application
    // has an action associated with it:
    Run: func(cmd *cobra.Command, args []string) {
        path, _ := cmd.Flags().GetString("path")
	    if path != "" {
		comments := readFileTree(path)
		mdTableFormatter(comments)	
	    } else {
	        fmt.Println("ERROR: No path provided, please provide path using the -p flag")
	        os.Exit(1)
	    }
	},
}

// Execute adds all child commands to the root command and sets flags appropriately.
// This is called by main.main(). It only needs to happen once to the rootCmd.
func Execute() {
    err := rootCmd.Execute()
    if err != nil {
	os.Exit(1)
    }
}

func init() {
    rootCmd.PersistentFlags().StringP("path", "p", "","assign the path to get comments from.")
}
func readFileTree(path string) []Comment {
    fsys := os.DirFS(path)
    var comments []Comment

    // Walk through all files in the directory
    fs.WalkDir(fsys, ".", func(p string, d fs.DirEntry, err error) error {
        if err != nil {
            return err
        }

        // Check if file has .go extension
        if filepath.Ext(p) == ".go" {
            // Read the file and check for comments
            file, err := os.Open(filepath.Join(path, p))
            if err != nil {
                return err
            }
            defer file.Close()

            // Process each line in the file
            scanner := bufio.NewScanner(file)
	    ln := 0
            for scanner.Scan() {
		line := scanner.Text()
		ln++
		//TODO: P:0 add support for TODO's not at start of line
		//TODO: P:0 add multiline support /* */
                // Check for C-style comments (// and )
                if strings.HasPrefix(strings.TrimSpace(line), "//TODO:") {
                    // Regular expression to match "P:" followed by a digit
                    re := regexp.MustCompile(`P:(\d)`)

                    // Trim spaces and remove the "//TODO:" prefix
                    trimmedLine := strings.TrimSpace(line)
                    trimmedLine = strings.TrimPrefix(trimmedLine, "//TODO: ")

                    // Try to find the priority
                    matches := re.FindStringSubmatch(trimmedLine)
    
                    // If a priority is found, remove it and print the comment and priority
                    if len(matches) > 1 {
                        // Remove the "P:<digit>" from the beginning of the line
                        trimmedLine = strings.Replace(trimmedLine, matches[0], "", 1) // Replace only the first occurrence
			// Store the file_path, line_number, comment, and priority as vars to be used in constructing a Comment object.
			priority,err := strconv.Atoi(matches[1])
			if err != nil {
			    return err
			}

			file,task := filepath.Join(path, p), strings.TrimSpace(trimmedLine) 
			
			comment := Comment{file,ln,priority,task}
			comments = append(comments,comment)
                    } else {
			file,task := filepath.Join(path, p), strings.TrimSpace(trimmedLine) 
                        comment := Comment{file,ln,9,task}
			comments = append(comments,comment)
		    }
                }

            }

            // Check if there was any error reading the file
            if err := scanner.Err(); err != nil {
                return err
            }
        }
        return nil
    })
    return comments
}

func mdTableFormatter(comments []Comment) {
	fmt.Println("| File Path | Line Number | Priority | Task |")
	fmt.Println("| --------- | ----------- | -------- | ---- |")
	for _, comment := range comments {
    		// You can access each `comment` here
		fmt.Printf("| %s | %d | %d | %s |\n",comment.FilePath,comment.LineNumber,comment.Priority,comment.Task)
	}
}