package main

import (
    "fmt"
    "strings"
)

func main() {
    // Inférence de type avec :=
    indicatif := "F4HXN"
    freq      := 14.074

    // Déclaration explicite
    var puissance int = 100

    // Constante — valeur fixée à la compilation
    const mode = "FT8"

    fmt.Printf("%s — %.3f MHz — %s — %d W\n",
        indicatif, freq, mode, puissance)

    // for est le seul mot-clé de boucle en Go
    for i := 0; i < 3; i++ {
        fmt.Println(strings.ToUpper(indicatif))
    }

    // Boucle infinie (while en Go)
    for {
        break
    }

    // Switch sans break explicite
    switch mode {
    case "FT8":
        fmt.Println("Mode digital — séquences de 15 secondes")
    case "SSB":
        fmt.Println("Voix — bande latérale unique")
    default:
        fmt.Println("Mode non reconnu")
    }
}

// Retours multiples — idiome fondamental de Go
func diviser(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division par zéro impossible")
    }
    return a / b, nil
}

// Fonction variadique — nombre variable d'arguments
func somme(valeurs ...int) int {
    total := 0
    for _, v := range valeurs {
        total += v
    }
    return total
}

// defer — s'exécute à la sortie de la fonction, garanti
func lireFichier(nom string) error {
    f, err := os.Open(nom)
    if err != nil {
        return err
    }
    defer f.Close()  // exécuté même en cas de panique
    // ... traitement du fichier
    return nil
}

// Utilisation
result, err := diviser(10, 3)
if err != nil {
    fmt.Println("Erreur :", err)
    return
}
fmt.Printf("%.4f\n", result)         // 3.3333
fmt.Println(somme(1, 2, 3, 4, 5))   // 15

// Struct de base
type Antenne struct {
    Type   string
    GainDB float64
}

// Embedding — Transceiver hérite des champs de Antenne
type Transceiver struct {
    Indicatif string
    Freq      float64
    Mode      string
    Antenne           // intégration directe
}

// Méthode avec récepteur pointeur — modifie la struct
func (t *Transceiver) ChangerFreq(f float64) {
    t.Freq = f
}

// Méthode avec récepteur valeur — lecture seule
func (t Transceiver) String() string {
    return fmt.Sprintf("%s @ %.3f MHz [%s] antenne: %s +%.1f dBd",
        t.Indicatif, t.Freq, t.Mode, t.Type, t.GainDB)
}

func main() {
    trx := Transceiver{
        Indicatif: "F4HXN",
        Freq:      14.074,
        Mode:      "FT8",
        Antenne:   Antenne{Type: "Dipôle", GainDB: 0.0},
    }
    trx.ChangerFreq(7.074)
    fmt.Println(trx.String())
    // F4HXN @ 7.074 MHz [FT8] antenne: Dipôle +0.0 dBd

    // Accès direct aux champs de Antenne via embedding
    fmt.Println(trx.GainDB)  // 0 — champ de Antenne accessible directement
}

// Interface — contrat de comportement
type Emetteur interface {
    Transmettre(msg string)
    Frequence() float64
}

// Radio satisfait Emetteur — sans le déclarer
type Radio struct{ Freq float64 }
func (r Radio) Transmettre(msg string)  { fmt.Println("TX:", msg) }
func (r Radio) Frequence() float64      { return r.Freq }

// Repeteur satisfait aussi Emetteur
type Repeteur struct{ Freq, Shift float64 }
func (r Repeteur) Transmettre(msg string)  { fmt.Println("REP:", msg) }
func (r Repeteur) Frequence() float64      { return r.Freq + r.Shift }

// Fonction polymorphe — accepte n'importe quel Emetteur
func demarrer(e Emetteur) {
    fmt.Printf("Ecoute sur %.3f MHz\n", e.Frequence())
    e.Transmettre("CQ CQ DE F4HXN")
}

func main() {
    emetteurs := []Emetteur{
        Radio{Freq: 14.225},
        Repeteur{Freq: 145.600, Shift: -0.600},
    }
    for _, e := range emetteurs {
        demarrer(e)
    }
}

package main

import (
    "fmt"
    "sync"
    "time"
)

func analyserBande(bande string, duree time.Duration, wg *sync.WaitGroup) {
    defer wg.Done()          // signale la fin, quoi qu'il arrive
    time.Sleep(duree)         // simulation d'analyse
    fmt.Printf("[%s] analyse terminée\n", bande)
}

func main() {
    var wg sync.WaitGroup

    bandes := []string{"10m", "15m", "20m", "40m", "80m"}

    for _, b := range bandes {
        wg.Add(1)
        go analyserBande(b, 100*time.Millisecond, &wg)
        // go lance une goroutine — non bloquant
    }

    wg.Wait()   // attend toutes les goroutines
    fmt.Println("Toutes les bandes analysées en parallèle")
}

// Pipeline : générateur → filtre → consommateur

func generer(spots ...string) <-chan string {
    ch := make(chan string)
    go func() {
        for _, s := range spots {
            ch <- s
        }
        close(ch)
    }()
    return ch
}

func filtrerFrance(in <-chan string) <-chan string {
    out := make(chan string)
    go func() {
        for spot := range in {
            if strings.HasPrefix(spot, "F") {
                out <- spot
            }
        }
        close(out)
    }()
    return out
}

func main() {
    source   := generer("F4HXN", "DL3XY", "F5ZVP", "W1AW", "TK1AB")
    francais := filtrerFrance(source)

    for spot := range francais {
        fmt.Println("Spot FR :", spot)
    }
    // Spot FR : F4HXN
    // Spot FR : F5ZVP
}

// select — multiplexage de plusieurs channels
select {
case msg := <-ch1:
    fmt.Println("reçu sur ch1 :", msg)
case msg := <-ch2:
    fmt.Println("reçu sur ch2 :", msg)
case <-time.After(5 * time.Second):
    fmt.Println("timeout — aucun message")
}

// Erreur personnalisée avec contexte structuré
type ErrFrequence struct {
    Freq   float64
    Raison string
}

func (e *ErrFrequence) Error() string {
    return fmt.Sprintf("fréquence %.3f MHz invalide : %s", e.Freq, e.Raison)
}

func validerFreq(f float64) error {
    if f < 1.8 || f > 30.0 {
        return &ErrFrequence{Freq: f, Raison: "hors bandes HF 160m-10m"}
    }
    return nil
}

// Wrapping d'erreur — chaîne contextuelle (Go 1.13+)
func configurerTRX(f float64) error {
    if err := validerFreq(f); err != nil {
        return fmt.Errorf("configuration transceiver : %w", err)
    }
    return nil
}

func main() {
    err := configurerTRX(50.0)  // 50 MHz hors bandes HF

    // errors.As — inspecte le type concret dans la chaîne
    var fe *ErrFrequence
    if errors.As(err, &fe) {
        fmt.Printf("Fréquence problématique : %.1f MHz\n", fe.Freq)
    }
    fmt.Println(err)
    // configuration transceiver : fréquence 50.000 MHz invalide : hors bandes HF
}

package main

import (
    "encoding/json"
    "log"
    "net/http"
)

type Spot struct {
    Indicatif string  `json:"indicatif"`
    Freq      float64 `json:"freq_mhz"`
    Mode      string  `json:"mode"`
}

func spotsHandler(w http.ResponseWriter, r *http.Request) {
    spots := []Spot{
        {"F4HXN", 14.074, "FT8"},
        {"F5ZVP", 7.100,  "SSB"},
    }
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(spots)
}

func main() {
    http.HandleFunc("/api/spots", spotsHandler)
    log.Println("API DX Cluster sur :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}