func IsAnInteractiveSession() bool {
	isIntSess, err := svc.IsAnInteractiveSession()
	if err != nil {
		log.Fatalf("winsvc.InServiceMode: svc.IsAnInteractiveSession(): err = %v", err)
	}
	return isIntSess
}

func init() {
	var err error
	interactive, err = svc.IsAnInteractiveSession()
	if err != nil {
		panic(err)
	}
}

func win_service_main() {
	const svcName = "scollector"
	var err error
	switch *win_service_command {
	case "install":
		err = installService(svcName, "Stack Exchange's Metric Collection Agent")
	case "remove":
		err = removeService(svcName)
	case "start":
		err = startService(svcName)
	case "stop":
		err = controlService(svcName, svc.Stop, svc.Stopped)
	case "":
		isIntSess, err := svc.IsAnInteractiveSession()
		if err != nil {
			slog.Fatalf("failed to determine if we are running in an interactive session: %v", err)
		}
		if !isIntSess {
			go runService(svcName, false)
		}
		return
	default:
		slog.Fatalf("unknown winsvc command: %v", *win_service_command)
	}
	if err != nil {
		slog.Fatalf("failed to %s %s: %v", *win_service_command, svcName, err)
	}
	os.Exit(0)
}

func main() {
	var logDir = ""
	flag.StringVar(&logDir, "logDir", "", "The directory where the logs will be stored")
	var serviceName = flag.String("serviceName", "mssql_broker", "The name of the service as installed in Windows SCM")

	if !flag.Parsed() {
		flag.Parse()
	}

	interactiveMode, err := svc.IsAnInteractiveSession()
	if err != nil {
		panic(err.Error())
	}

	if interactiveMode {
		runMain(os.Stdout)
	} else {
		var err error

		if logDir == "" {
			//will default to %windir%\System32\
			workingDir, err := os.Getwd()
			if err != nil {
				panic(err.Error())
			}
			logDir = path.Join(workingDir, "logs")
		}
		if _, err := os.Stat(logDir); os.IsNotExist(err) {
			err := os.Mkdir(logDir, 0666)
			if err != nil {
				panic(err.Error())
			}
		}

		logFilePath := path.Join(logDir, "mssql_broker.log")

		logFile, err := os.OpenFile(logFilePath, os.O_WRONLY|os.O_CREATE|os.O_APPEND|os.O_SYNC, 0660)
		if err != nil {
			panic(err.Error())
		}
		defer logFile.Close()

		//setting stderr & stdout
		os.Stdout = logFile
		os.Stderr = logFile

		fileWriter := NewWinFileWriter(logFile)

		ws := WindowsService{
			writer: fileWriter,
		}

		err = svc.Run(*serviceName, &ws)
		if err != nil {
			panic(err.Error())
		}
	}
}

func initService(daemonCli *DaemonCli) (bool, error) {
	if *flUnregisterService {
		if *flRegisterService {
			return true, errors.New("--register-service and --unregister-service cannot be used together")
		}
		return true, unregisterService()
	}

	if *flRegisterService {
		return true, registerService()
	}

	if !*flRunService {
		return false, nil
	}

	interactive, err := svc.IsAnInteractiveSession()
	if err != nil {
		return false, err
	}

	h := &handler{
		tosvc:     make(chan bool),
		fromsvc:   make(chan error),
		daemonCli: daemonCli,
	}

	var log *eventlog.Log
	if !interactive {
		log, err = eventlog.Open(*flServiceName)
		if err != nil {
			return false, err
		}
	}

	logrus.AddHook(&etwHook{log})
	logrus.SetOutput(ioutil.Discard)

	service = h
	go func() {
		if interactive {
			err = debug.Run(*flServiceName, h)
		} else {
			err = svc.Run(*flServiceName, h)
		}

		h.fromsvc <- err
	}()

	// Wait for the first signal from the service handler.
	err = <-h.fromsvc
	if err != nil {
		return false, err
	}
	return false, nil
}

// If the application is running in an interactive session, run until
// terminated. Otherwise, run the application as a Windows service.
func Exec() error {
	isInteractive, err := svc.IsAnInteractiveSession()
	if err != nil {
		return err
	}
	if !isInteractive {
		return svc.Run(ServiceName, &service{})
	} else {
		execSignal()
		return nil
	}
}

func NewWindowsService(i WindowsServiceInterface, c *WindowsServiceConfig) (Service, error) {
	var err error

	interactive, err = svc.IsAnInteractiveSession()
	if err != nil {
		return nil, err
	}
	ws := &windowsService{
		i:      i,
		Config: c,
	}
	return ws, nil
}

func runService(context *cli.Context) error {
	interactive, err := svc.IsAnInteractiveSession()
	if err != nil {
		return fmt.Errorf("Failed to detect interactive session: %s", err)
	}

	s := service{context, interactive}

	if interactive {
		return debug.Run(lib.ConnectorName, &s)
	} else {
		return svc.Run(lib.ConnectorName, &s)
	}
}

func RunService(context *cli.Context) {
	interactive, err := svc.IsAnInteractiveSession()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Failed to detect interactive session: %s\n", err)
		os.Exit(1)
	}

	s := service{context, interactive}

	if interactive {
		debug.Run(lib.ConnectorName, &s)
	} else {
		svc.Run(lib.ConnectorName, &s)
	}
}

func platformInit(config *Config) error {
	isInteractive, err := svc.IsAnInteractiveSession()
	if err != nil {
		return err
	}
	if !isInteractive {
		h, err := newEventLogHook()
		if err != nil {
			return err
		}
		hook = h
		logrus.AddHook(hook)
	}
	return nil
}

func main() {
	if len(os.Args) < 2 {
		runApp()
		return
	}
	const svcName = "DirectPrintServer"

	isIntSess, err := svc.IsAnInteractiveSession()
	if err != nil {
		log.Fatalf("failed to determine if we are running in an interactive session: %v", err)
	}
	if !isIntSess {
		runService(svcName, false)
		return
	}

	if len(os.Args) < 2 {
		usage("no command specified")
	}

	cmd := strings.ToLower(os.Args[1])
	switch cmd {
	case "debug":
		runService(svcName, true)
		return
	case "start":
		runApp()
		return
	case "install_s":
		err = installService(svcName, "Direct Print Server")
	case "remove_s":
		err = removeService(svcName)
	case "start_s":
		err = startService(svcName)
	case "stop_s":
		err = controlService(svcName, svc.Stop, svc.Stopped)
	case "pause_s":
		err = controlService(svcName, svc.Pause, svc.Paused)
	case "continue_s":
		err = controlService(svcName, svc.Continue, svc.Running)
	default:
		usage(fmt.Sprintf("invalid command %s", cmd))
	}
	if err != nil {
		log.Fatalf("failed to %s %s: %v", cmd, svcName, err)
	}
	return
}

func main() {
	isIntSess, err := svc.IsAnInteractiveSession()
	if err != nil {
		log.Fatalf("etcd: failed to determine if we are running in an interactive session: %v", err)
	}
	if !isIntSess {
		svcName := filepath.Base(os.Args[0])
		if strings.HasSuffix(strings.ToLower(svcName), ".exe") {
			svcName = svcName[:len(svcName)-len(".exe")]
		}
		runAsService(svcName)
		return
	}

	etcdmain.Main()
}

func HandleService() chan int {
	res := make(chan int)
	go func() {
		isIntSess, err := svc.IsAnInteractiveSession()
		if err != nil {
			log.Fatalf("failed to determine if we are running in an interactive session: %v", err)
		}
		if !isIntSess {
			log.Println("runService(svcName, false)")
			svc.Run("Concordis", &myservice{res})
		} else {
			log.Println("A standard consle session")
		}
	}()
	return res
}

// Returns true if we detected that we are not running in a non-interactive session, and so
// launched the service. This function will not return until the service exits.
func RunAsService(handler func()) bool {
	interactive, err := svc.IsAnInteractiveSession()
	if err != nil {
		log.Fatalf("failed to determine if we are running in an interactive session: %v", err)
		return false
	}
	if interactive {
		return false
	}

	serviceName := "" // this doesn't matter when we are a "single-process" service
	service := &myservice{
		handler: handler,
	}
	svc.Run(serviceName, service)
	return true
}

// On windows this creates a loop that only finishes when
// a Stop or Shutdown request is received. On non-windows
// platforms, the function does nothing. The stopCallback
// function is called when the Stop/Shutdown request is
// received.
func ProcessWindowsControlEvents(stopCallback func()) {
	isInteractive, err := svc.IsAnInteractiveSession()
	if err != nil {
		logp.Err("IsAnInteractiveSession: %v", err)
		return
	}
	logp.Debug("service", "Windows is interactive: %v", isInteractive)

	run := svc.Run
	if isInteractive {
		run = debug.Run
	}
	err = run(os.Args[0], &beatService{})
	if err != nil {
		logp.Err("Error: %v", err)
	} else {
		stopCallback()
	}
}

func init() {
	interactive, err := svc.IsAnInteractiveSession()
	if err != nil {
		panic(err)
	}
	if interactive {
		return
	}
	go func() {
		_ = svc.Run("", runner{})

		guard.Lock()
		f := onExit
		guard.Unlock()

		// Don't hold this lock in user code.
		if f != nil {
			f()
		}
		// Make sure we exit.
		os.Exit(0)
	}()
}

func main() {
	// initialize logger
	log := logger.Logger()
	defer log.Close()
	defer log.Flush()

	// parse input parameters
	parseFlags(log)

	// check whether this is an interactive session
	isIntSess, err := svc.IsAnInteractiveSession()
	if err != nil {
		log.Warnf("Failed to determine if we are running in an interactive session: %v", err)
	}

	// isIntSess is false by default (after declaration), this fits the use
	// case that agent is running as Windows service most of times
	switch isIntSess {
	case true:
		run(log)
	case false:
		svc.Run(serviceName, &amazonSSMAgentService{log: log})
	}
}

func main() {
	flag.Usage = usage
	flag.Parse()

	playEnabled = *flagShowPlayground

	if *flagServiceInstall {
		var args []string
		args = append(args, fmt.Sprintf("-goroot=%s", *flagGoroot))
		for i := 1; i < len(os.Args); i++ {
			if strings.HasPrefix(os.Args[i], "-service-install") {
				continue
			}
			if strings.HasPrefix(os.Args[i], "-goroot") {
				continue
			}
			args = append(args, os.Args[i])
		}
		if *flagHttpAddr == "" {
			args = append(args, "-http=:6060")
		}
		if err := installService(ServiceName, ServiceDesc, args...); err != nil {
			log.Fatalf("installService(%s, %s): %v", ServiceName, ServiceDesc, err)
		}
		fmt.Printf("Done\n")
		return
	}
	if *flagServiceUninstall {
		if err := removeService(ServiceName); err != nil {
			log.Fatalf("removeService: %v\n", err)
		}
		fmt.Printf("Done\n")
		return
	}
	if *flagServiceStart {
		if err := startService(ServiceName); err != nil {
			log.Fatalf("startService: %v\n", err)
		}
		fmt.Printf("Done\n")
		return
	}
	if *flagServiceStop {
		if err := controlService(ServiceName, svc.Stop, svc.Stopped); err != nil {
			log.Fatalf("stopService: %v\n", err)
		}
		fmt.Printf("Done\n")
		return
	}

	// Check usage: either server and no args, command line and args, or index creation mode
	if (*flagHttpAddr != "" || *flagUrlFlag != "") != (flag.NArg() == 0) && !*flagWriteIndex {
		usage()
	}

	// run as service
	if isIntSess, err := svc.IsAnInteractiveSession(); err == nil && !isIntSess {
		runService(ServiceName)
		return
	}

	runGodoc()
}