package main

import (
	"bufio"
	"fmt"
	"gosh/cmd"
	"gosh/types"
	"os"
	"strings"

	"github.com/fatih/color"
)

func gosh_print_output(cmdo types.CmdOutput) {
	switch cmdo.Id {
	case 0:
		fmt.Printf(cmdo.Output)
	case 1:
		fmt.Printf("Error: %s\n", cmdo.Output)
	}
}

func parse_flags(parts []string) (map[string]string, []string) {
	flags := make(map[string]string)
	args := []string{}
	i := 0
	for i < len(parts) {
		if strings.HasPrefix(parts[i], "-") {
			key := parts[i]
			val := ""
			if i+1 < len(parts) && !strings.HasPrefix(parts[i+1], "-") {
				val = parts[i+1]
				i++
			}
			flags[key] = val
		} else {
			args = append(args, parts[i])
		}
		i++
	}
	return flags, args
}

func gosh_process_input(sh *types.Shell, input string) {
	// Split by pipe and trim spaces
	commands := strings.Split(input, "|")
	var prevOutput types.CmdOutput

	for _, cmdStr := range commands {
		cmdStr = strings.TrimSpace(cmdStr)
		parts := strings.Fields(cmdStr)
		if len(parts) == 0 {
			continue
		}

		switch parts[0] {
		case "pwd":
			prevOutput = cmd.GoshPwd(sh)
		case "cd":
			if len(parts) < 2 {
				fmt.Println("Usage: cd <dir>")
				return
			}
			prevOutput = cmd.GoshCd(sh, parts[1])
		case "ls":
			prevOutput = cmd.GoshLs(sh)
		case "cat":
			if len(parts) < 2 {
				fmt.Println("Usage: cat <path to file>")
				return
			}
			prevOutput = cmd.GoshCat(sh, parts[1])
		case "grep":
			if len(parts) < 2 {
				fmt.Println("Usage: grep <pattern>")
				return
			}

			flags, args := parse_flags(parts)

			// Feed previous output to grep
			prevOutput = cmd.GoshGrep(sh, flags, prevOutput.Output, args[len(args)-1])
		case "clear":
			cmd.GoshClear()
		default:
			fmt.Println("Unknown command: ", parts[0])
			return
		}
	}

	gosh_print_output(prevOutput)
}

func main() {
	reader := bufio.NewReader(os.Stdin)

	c := color.New(color.FgCyan)

	dir, _ := os.Getwd()
	sh := types.Shell{Cd: dir}

	var should_exit = false
	for {
		c.Print(sh.Cd)
		fmt.Print("> ")

		input, err := reader.ReadString('\n')

		if err != nil {
			fmt.Println("Error reading input: ", err)
		}

		input = strings.TrimSpace(input)

		switch input {
		case "exit":
			should_exit = true
		default:
			gosh_process_input(&sh, input)
		}

		if should_exit {
			break
		}
	}
}