package main

import (
	"context"
	"fmt"
	"io"

	"github.com/wailsapp/wails/v2/pkg/runtime"

	"gitea.neitzel.de/konrad/funknetz/audio"
	"gitea.neitzel.de/konrad/funknetz/station"
)

// App is the window's view of the station.
type App struct {
	ctx     context.Context
	cancel  context.CancelFunc
	station *station.Station
	quit    func(context.Context)
}

func (a *App) startup(ctx context.Context) {
	a.ctx = ctx
	runCtx, cancel := context.WithCancel(ctx)
	a.cancel = cancel
	if err := audio.Start(runCtx, a.station.WriteMicrophone, a.station.TakePlayback); err != nil {
		a.station.Fail("could not open the audio device")
		return
	}
	go func() { _ = a.station.Run(runCtx) }() // Run returns when the window closes.
}

func (a *App) shutdown(context.Context) {
	if a.cancel != nil {
		a.cancel()
	}
}

// State returns the station state the page renders.
func (a *App) State() station.State { return a.station.State() }

// HoldButton reports that the on-screen button is held.
func (a *App) HoldButton() { a.station.HoldButton() }

// ReleaseButton reports that the on-screen button was released.
func (a *App) ReleaseButton() { a.station.ReleaseButton() }

// HoldSpace reports that Space is held.
func (a *App) HoldSpace() { a.station.HoldSpace() }

// ReleaseSpace reports that Space was released.
func (a *App) ReleaseSpace() { a.station.ReleaseSpace() }

// Config returns the Config window form.
func (a *App) Config() station.ConfigState { return a.station.Config() }

// OpenConfig opens the Config window, re-reading the file.
func (a *App) OpenConfig() { a.station.OpenConfig() }

// Save validates and writes the config form.
func (a *App) Save(form station.ConfigForm) error { return a.station.Save(form) }

// CancelConfig discards the form. When no config has loaded, it quits.
func (a *App) CancelConfig() {
	if !a.station.Cancel() {
		return
	}
	quit := a.quit
	if quit == nil {
		quit = runtime.Quit
	}
	if a.ctx != nil {
		quit(a.ctx)
	}
}

func openStation(args []string) (*station.Station, error) {
	path, err := resolveConfigPath(args)
	if err != nil {
		return nil, err
	}
	return station.New(station.Options{ConfigPath: path})
}

// openStationReported opens the station from args. A flag or path failure is
// one line on stderr and the returned error. A missing or invalid config still
// returns a station so the window can open.
func openStationReported(args []string, stderr io.Writer) (*station.Station, error) {
	st, err := openStation(args)
	if err != nil {
		// The returned error is the failure. A write error does not replace it.
		_, _ = fmt.Fprintln(stderr, err.Error())
		return nil, err
	}
	return st, nil
}