package argvpb

import "fmt"

// verify the application has the needed function calls defined
func verifyApplication(tmp interface{}) {
	// START NEEDED FUNCS           // 2025/10/18 (review in a few months)
	if tmp, ok := tmp.(initArgvI); ok {
		me.initArgvFunc = tmp.InitArgv
	} else {
		panic("you must define in your app the function: (args) func InitArgv() (string, string, string)")
	}

	if tmp, ok := tmp.(mustParseI); ok {
		me.mustParseFunc = tmp.MustParse
	} else {
		panic("you must define in your app the function: func (args) MustParse() error")
	}

	if tmp, ok := tmp.(writeHelpForAutocompleteI); ok {
		me.writeHelpForAutocompleteFunc = tmp.WriteHelpForAutocomplete
	} else {
		helpWriteHelpForAutocomplete()
	}

	if tmp, ok := tmp.(writeHelpForAutocompleteDebugI); ok {
		me.writeHelpForAutocompleteDebugFunc = tmp.WriteHelpForAutocompleteDebug
	} else {
		helpWriteHelpForAutocompleteDebug()
	}

	if tmp, ok := tmp.(writeHelpForSubcommandI); ok {
		me.writeHelpForSubcommandFunc = tmp.WriteHelpForSubcommand
	} else {
		helpWriteHelpForSubcommand()
	}

	if tmp, ok := tmp.(writeHelpI); ok {
		me.writeHelpFunc = tmp.WriteHelp
	} else {
		helpWriteHelp()
	}

	if tmp, ok := tmp.(parseFlagsI); ok {
		me.parseFlagsFunc = tmp.ParseFlags
	} else {
		parseFlagsHelp()
	}

	if tmp, ok := tmp.(initGuiI); ok {
		me.initGuiFunc = tmp.InitGui
		if err := tmp.InitGui(); err != nil {
			fmt.Println("go.wit.com/gui failed to initialize", err)
			panic("gui failed to init")
		}
	} else {
		// panic("you must add this function to argv.go: (argv) func InitGui() error")
	}
	// END NEEDED FUNCS // 2025/10/18 (review in a few months)

	// TODO: SORT OUT STUFF BELOW HERE
	if tmp, ok := tmp.(examplesI); ok {
		me.examples = tmp.Examples
	}
	if tmp, ok := tmp.(autoFuncI); ok {
		me.autoFunc = tmp.DoAutoComplete
	} else {
		// panic("you need to make the function argv.DoAutoComplete()")
	}

	if tmp, ok := tmp.(sendCompletionStringsI); ok {
		me.autoFunc = tmp.SendCompletionStrings
	} else {
		// panic("you need to make the function argv.DoAutoComplete()")
	}

	if tmp, ok := tmp.(exitI); ok {
		me.appExit = tmp.Exit
	} else {
		// panic("you need to make the function argv.Exit()")
	}
}

// WORKING ON START

type initArgvI interface {
	InitArgv() (string, string, string)
}

type mustParseI interface {
	MustParse() error
}

type parseFlagsI interface {
	ParseFlags([]string) error
}

type writeHelpForAutocompleteI interface {
	WriteHelpForAutocomplete(string, ...string) error
}

type writeHelpForAutocompleteDebugI interface {
	WriteHelpForAutocompleteDebug(string, ...string) error
}

type writeHelpForSubcommandI interface {
	WriteHelpForSubcommand(cmd string) error
}

type writeHelpI interface {
	WriteHelp() error
}

type initGuiI interface {
	// Version returns the version string that will be printed on a line by itself
	// at the top of the help message.
	InitGui() error
}

// WORKING ON END

// NOTSURE ABOUT START
type appnameI interface {
	// Version returns the version string that will be printed on a line by itself
	// at the top of the help message.
	Appname() string
}

// deprecate
type autoFuncI interface {
	// Version returns the version string that will be printed on a line by itself
	// at the top of the help message.
	DoAutoComplete(*Argv)
}

type sendCompletionStringsI interface {
	// Version returns the version string that will be printed on a line by itself
	// at the top of the help message.
	SendCompletionStrings(*Argv)
}

type buildtimeI interface {
	Buildtime() (string, string)
}

type examplesI interface {
	// Version returns the version string that will be printed on a line by itself
	// at the top of the help message.
	Examples() string
}

type guiI interface {
	// Version returns the version string that will be printed on a line by itself
	// at the top of the help message.
	ArgvGui() error
}

type exitI interface {
	// allows a custom app Exit()
	Exit()
}

func helpWriteHelpForSubcommand() {
	fmt.Println("")
	fmt.Println("// add this funcgion: this will print the help")
	fmt.Println("func (args) WriteHelpForSubcommand() error {")
	fmt.Println("	me.pp.WriteHelpForSubcommand(os.Stderr, me.argv.Cmd)")
	fmt.Println("	return nil")
	fmt.Println("}")
	fmt.Println("")
	fmt.Println("cp ~/go/src/go.wit.com/apps/forge/argv.template.go .")
	panic("copy the argv.template.go file from forge")
}

func helpWriteHelp() {
	fmt.Println("")
	fmt.Println("// add this funcgion: this will print the help")
	fmt.Println("func (args) WriteHelp() error {")
	fmt.Println("	me.pp.WriteHelp(os.Stderr)")
	fmt.Println("	return nil")
	fmt.Println("}")
	fmt.Println("")

	panic("best to just copy the argv.template.go file from forge")
}

func helpWriteHelpForAutocompleteDebug() {
	fmt.Println("")
	fmt.Println("// this will print the help for the subcmd")
	fmt.Println("func (args) WriteHelpForAutocompleteDebug(part string, subcmd ...string) error {")
	fmt.Println("	return argvpp.WriteHelpForAutocomplete(f, os.Stdout, part, subcmd...)")
	fmt.Println("}")
	fmt.Println("")
	fmt.Println("cp ~/go/src/go.wit.com/apps/forge/argv.template.go .")

	panic("best to just copy the argv.template.go file from forge")
}

// func (p *Parser) WriteHelpForAutocomplete(stderr io.Writer, stdout io.Writer, partial string, subcommand ...string) error {
// me.pp.WriteHelpForAutocomplete(os.Stderr, os.Stdout, partial, cmd...)
func helpWriteHelpForAutocomplete() {
	fmt.Println("")
	fmt.Println("// this will print the help for the subcmd")
	fmt.Println("func (args) WriteHelpForAutocomplete(part string, subcmd ...string) error {")
	fmt.Println("	return argvpp.WriteHelpForAutocomplete(os.Stderr, os.Stdout, part, subcmd...)")
	fmt.Println("}")
	fmt.Println("")
	fmt.Println("Just copy the argv.template.go file from forge")
	fmt.Println("")

	panic("you must define this function in your application code")
}

func parseFlagsHelp() {
	fmt.Println("")
	fmt.Println("// this function will send the current argv PB to go-args for parsing")
	fmt.Println("func (args) ParseFlags(flags []string) error {")
	fmt.Println("	arg.ParseFlags(flags)")
	fmt.Println("}")
	fmt.Println("")

	panic("you must define in your app the function: func (args) ParseFlags([]string) error")
}