package main

import (
	`errors`
	`fmt`
	`log`
	`os`

	`github.com/davecgh/go-spew/spew`
	`github.com/jessevdk/go-flags`
	`r00t2.io/gobroke/conf`
	`r00t2.io/gobroke/daemon`
	`r00t2.io/gobroke/runner`
	`r00t2.io/gobroke/version`
	`r00t2.io/goutils/logging`
)

func main() {

	var err error
	var args *Args = new(Args)
	var logger *logging.MultiLogger
	var cfg *conf.Config
	var logFlagsRuntime int = logFlags
	var singleResults []*runner.TunnelResult
	var tunsChanged bool
	var tunsUpdated bool
	var updater *daemon.Updater
	var flagsErr *flags.Error = new(flags.Error)
	var parser *flags.Parser = flags.NewParser(args, flags.Default)

	if _, err = parser.Parse(); err != nil {
		switch {
		case errors.As(err, &flagsErr):
			switch {
			case errors.Is(flagsErr.Type, flags.ErrHelp), errors.Is(flagsErr.Type, flags.ErrCommandRequired), errors.Is(flagsErr.Type, flags.ErrRequired): // These print their relevant messages by themselves.
				return
			default:
				log.Panicln(err)
			}
		default:
			log.Panicln(err)
		}
	}

	if version.Ver, err = version.Version(); err != nil {
		log.Panicln(err)
	}

	// If args.Version or args.DetailVersion are true, just print them and exit.
	if args.DetailVersion || args.Version {
		if args.Version {
			fmt.Println(version.Ver.Short())
			return
		} else if args.DetailVersion {
			fmt.Println(version.Ver.Detail())
			return
		}
	}

	// We want to set up logging before anything else.
	if args.DoDebug {
		logFlagsRuntime = logFlagsDebug
	}
	logger = logging.GetMultiLogger(args.DoDebug, "GoBroke")
	if err = getOsLogger(logger, logFlagsRuntime); err != nil {
		log.Panicln(err)
	}
	if err = logger.Setup(); err != nil {
		log.Panicln(err)
	}
	logger.Info("main: GoBroke version %v", version.Ver.Short())
	logger.Debug("main: GoBroke version (extended):\n%v", version.Ver.Detail())
	defer logger.Shutdown()

	logger.Debug("Initialized with args:\n%v", spew.Sdump(args))

	if cfg, err = conf.NewConfig(args.ConfigPath, args.DoDebug, logger); err != nil {
		logger.Err("main: Received error while initializing config: %v", err)
		log.Panicln(err)
	}

	if singleResults, tunsChanged, tunsUpdated, err = runner.Run(cfg, logger); err != nil {
		logger.Err("main: Received error while running startup checks/updates: %v", err)
		log.Panicln(err)
	}
	logger.Info("main: Startup check: Changed: %v, Updated: %v", tunsChanged, tunsUpdated)
	logger.Debug("main: Startup check: Tunnel results:\n%s", spew.Sdump(singleResults))

	if !args.Daemon {
		// Single run.
		logger.Debug("main: Done.")
		os.Exit(0)
	}

	if updater, err = daemon.NewUpdater(cfg, logger); err != nil {
		logger.Err("main: Received error while initializing persistent updater: %v", err)
		log.Panicln(err)
	}
	if err = updater.Start(); err != nil {
		logger.Err("main: Received error while starting/running persistent updater: %v", err)
		log.Panicln(err)
	}

	logger.Debug("main: Done.")
}