package main

import (
	"context"
	"flag"
	"fmt"
	"log/slog"
	"os"

	reach "forge.cadoles.com/cadoles/go-emlid/reach/client"
	"forge.cadoles.com/cadoles/go-emlid/reach/client/logger"
	"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol"
	"forge.cadoles.com/cadoles/go-emlid/reach/client/protocol/v2/model"
	"github.com/mitchellh/mapstructure"
	"github.com/pkg/errors"
)

var (
	host         string = "192.168.42.1"
	rawLogLevel  string = "ERROR"
	baseAccuracy string = "fix"
)

func init() {
	flag.StringVar(&rawLogLevel, "log-level", rawLogLevel, "log level")
	flag.StringVar(&host, "host", host, "the reachrs module host")
	flag.StringVar(&baseAccuracy, "baseAccuracy", baseAccuracy, "precision required for average position")
}

func main() {
	flag.Parse()

	ctx := context.Background()

	client, err := initializeClient(ctx)
	if err != nil {
		fmt.Printf("[FATAL] %+v", err)
		os.Exit(1)
	}
	defer closeClient(ctx, client)
	/// setModem
	if err := updateModem(ctx, client); err != nil {
		fmt.Printf("[FATAL] %+v", err)
		os.Exit(1)
	}
	// Récupération de la configuration
	config, err := retrieveAndProcessConfig(ctx, client)
	if err != nil {
		fmt.Printf("[FATAL] %+v", err)
		os.Exit(1)
	}

	fmt.Printf("Configuration actuelle de la base :\n lat=%v\n lon=%v\n height=%v\n antenna_offset=%v\n  accumulation=%v\n\n NTRIPSettings: \n address:%s\n port:%d \n username: %s\n password:%s\n sendPositionToBase:%t\n",
		config.BaseMode.BaseCoordinates.Coordinates.Latitude, config.BaseMode.BaseCoordinates.Coordinates.Longitude, config.BaseMode.BaseCoordinates.Coordinates.Height, config.BaseMode.BaseCoordinates.AntennaOffset, config.BaseMode.BaseCoordinates.Accumulation, config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Address, config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Port, config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Username, config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Password, config.CorrectionInput.BaseCorrections.Settings.Ntripcli.SendPositionToBase)

	//NTRIP Correction
	processNTRIPCorrection(ctx, client, config)

	//Base configuration
	if err := setBaseToModeAndHold(ctx, client, config, baseAccuracy, 30); err != nil {
		fmt.Printf("[FATAL] %+v", err)
		os.Exit(1)
	}

	// AveragePosition
	processAveragePosition(ctx, client)
}

func initializeClient(ctx context.Context) (*reach.Client, error) {
	logLevel, err := logger.ParseLevel(rawLogLevel)
	if err != nil {
		return nil, errors.WithStack(err)
	}

	slog.SetLogLoggerLevel(logLevel)

	client := reach.NewClient(host)
	if err := client.Connect(ctx); err != nil {
		return nil, errors.WithStack(err)
	}

	return client, nil
}

func closeClient(ctx context.Context, client *reach.Client) {
	if err := client.Close(ctx); err != nil {
		fmt.Printf("[ERROR] Erreur lors de la fermeture: %+v", errors.WithStack(err))
	}
}

func retrieveAndProcessConfig(ctx context.Context, client *reach.Client) (*model.Configuration, error) {
	configData, err := client.Configuration(ctx)
	if err != nil {
		return nil, errors.WithStack(err)
	}

	var config model.Configuration
	if err := mapstructure.Decode(configData, &config); err != nil {
		return nil, errors.WithStack(err)
	}

	return &config, nil
}

func processNTRIPCorrection(ctx context.Context, client *reach.Client, config *model.Configuration) {
	// Configuration des corrections NTRIP
	ntripMsg, err := setupNTRIPCorrections(ctx, client)
	if err != nil {
		fmt.Printf("[FATAL] %+v", err)
		os.Exit(1)
	}
	displayAvailableMountPoint(ntripMsg)
	updateNTRIPMountPoint(ctx, client, config)
}

func setupNTRIPCorrections(ctx context.Context, client *reach.Client) (*protocol.TaskMessage[protocol.NTRIPPayload], error) {
	fmt.Println("\nConfiguration des corrections NTRIP...")

	// Recherche de points de montage
	ntripMsg, err := client.GetNTRIPMountPoint(ctx)
	if err != nil {
		return nil, errors.WithStack(err)
	}
	return ntripMsg, nil
}

func displayAvailableMountPoint(response *protocol.TaskMessage[protocol.NTRIPPayload]) {
	streams := response.Payload.Str
	fmt.Printf("=== %d Streams disponibles ===\n", len(streams))
	fmt.Printf("=== Base < 50 km disponibles ===\n")
	for i, stream := range streams {
		if stream.Distance < 50 {
			fmt.Printf("%d. %-15s | %s (%s) | %.1fkm\n",
				i+1,
				stream.Mountpoint,
				stream.ID,
				stream.Country,
				stream.Distance)
		}
	}
}

func updateNTRIPMountPoint(ctx context.Context, client *reach.Client, config *model.Configuration) error {
	opts := []protocol.SetBaseCorrectionsFunc{
		protocol.WithNTRIPAddress(config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Address),
		protocol.WithNTRIPPort(config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Port),
		protocol.WithNTRIPUsername(config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Username),
		protocol.WithNTRIPPassword(config.CorrectionInput.BaseCorrections.Settings.Ntripcli.Password),
		// todo modification du point de montage ici
		protocol.WithNTRIPMountPoint("EPI21"),
		protocol.WithSendPositionToBase(true),
	}

	if err := client.SetBaseCorrections(ctx, opts...); err != nil {
		return errors.WithStack(err)
	}

	fmt.Println("MountPoint NTRIP mis à jour")
	return nil
}

func setBaseToModeAndHold(ctx context.Context, client *reach.Client, baseConfig *model.Configuration, mode string, accumulation int) error {
	fmt.Printf("Configuration de la base en mode %s-and-hold...\n", baseAccuracy)

	opts := []protocol.SetBaseOptionFunc{
		protocol.WithBaseLatitude(baseConfig.BaseMode.BaseCoordinates.Coordinates.Latitude),
		protocol.WithBaseLongitude(baseConfig.BaseMode.BaseCoordinates.Coordinates.Longitude),
		protocol.WithBaseHeight(baseConfig.BaseMode.BaseCoordinates.Coordinates.Height),
		protocol.WithBaseAntennaOffset(baseConfig.BaseMode.BaseCoordinates.AntennaOffset),
		protocol.WithBaseMode(fmt.Sprintf("%s-and-hold", mode)),
		protocol.WithAccumulation(accumulation),
	}

	if err := client.SetBase(ctx, opts...); err != nil {
		return errors.WithStack(err)
	}

	fmt.Printf("Base configurée en mode %s-and-hold\n", baseAccuracy)
	return nil
}

func processAveragePosition(ctx context.Context, client *reach.Client) {
	// Collecte des données de positions
	messageTask, err := averagePosition(ctx, client)
	if err != nil {
		fmt.Printf("[FATAL] %+v", err)
		os.Exit(1)
	}
	displayAveragePositionMessage(messageTask)
	saveAveragedPosition(ctx, client, messageTask)

	fmt.Println("Configuration terminée avec succès")
}

func averagePosition(ctx context.Context, client *reach.Client) (*protocol.TaskMessage[protocol.AveragePositionPayload], error) {
	fmt.Println("Démarrage de la moyenne des position...")
	messageTask, err := client.AveragePosition(ctx)
	if err != nil {
		return nil, errors.WithStack(err)
	}
	return messageTask, nil

}

func displayAveragePositionMessage(message *protocol.TaskMessage[protocol.AveragePositionPayload]) error {
	fmt.Printf("Position moyennée: lat=%g, lon=%g, altitude=%g\n",
		message.Payload.Coordinates.Latitude, message.Payload.Coordinates.Longitude, message.Payload.Coordinates.Height)
	return nil

}

func saveAveragedPosition(ctx context.Context, client *reach.Client, message *protocol.TaskMessage[protocol.AveragePositionPayload]) error {
	opts := []protocol.SetBaseOptionFunc{
		protocol.WithBaseLatitude(message.Payload.Coordinates.Latitude),
		protocol.WithBaseLongitude(message.Payload.Coordinates.Longitude),
		protocol.WithBaseHeight(message.Payload.Coordinates.Height),
		protocol.WithBaseAntennaOffset(message.Payload.AntennaOffset),
		protocol.WithBaseMode("manual"),
	}

	if err := client.SetBase(ctx, opts...); err != nil {
		return errors.WithStack(err)
	}

	fmt.Println("Position sauvegardée en configuration")
	return nil
}

func updateModem(ctx context.Context, client *reach.Client) error {
	opts := []protocol.SetModemOptionsFunc{
		protocol.WithApn("mmsbouygtel.com"),
	}

	if err := client.SetModem(ctx, opts...); err != nil {
		return errors.WithStack(err)
	}

	fmt.Println("Modem mis à jour")
	return nil
}