package main

import (
    "context"
    "flag"
    "log"
    "os"
    "os/signal"
    "syscall"
)

func main() {
    port := flag.String("port", "8080", "listen port")
    debug := flag.Bool("debug", false, "verbose logging")
    flag.Parse()

    host := os.Getenv("APP_HOST")
    if host == "" {
        host = "localhost"
    }

    ctx, stop := signal.NotifyContext(
        context.Background(),
        syscall.SIGINT, syscall.SIGTERM,
    )
    defer stop()

    if *debug {
        log.SetFlags(log.LstdFlags | log.Lshortfile)
    }
    log.Printf("starting on %s:%s", host, *port)

    if err := serve(ctx, host, *port); err != nil {
        log.Fatal(err)
    }
}

// Hand-rolled fake. Every new method = another field + another assertion.
type fakeStore struct {
    getCalls  []string
    getReturn map[string]Order
    getErr    error

    putCalls  []Order
    putErr    error
}

func (f *fakeStore) Get(_ context.Context, id string) (Order, error) {
    f.getCalls = append(f.getCalls, id)
    return f.getReturn[id], f.getErr
}
func (f *fakeStore) Put(_ context.Context, o Order) error {
    f.putCalls = append(f.putCalls, o)
    return f.putErr
}

func TestProcess(t *testing.T) {
    s := &fakeStore{getReturn: map[string]Order{"o-1": {ID: "o-1"}}}
    if err := Process(context.Background(), s, "o-1"); err != nil {
        t.Fatal(err)
    }
    if len(s.getCalls) != 1 || s.getCalls[0] != "o-1" {
        t.Fatalf("Get not called as expected: %v", s.getCalls)
    }
}

func TestFetchUser(t *testing.T) {
    srv := httptest.NewServer(http.HandlerFunc(
        func(w http.ResponseWriter, r *http.Request) {
            if r.URL.Path != "/users/42" {
                http.NotFound(w, r)
                return
            }
            if r.Header.Get("Authorization") == "" {
                http.Error(w, "no auth", http.StatusUnauthorized)
                return
            }
            w.Header().Set("Content-Type", "application/json")
            _, _ = w.Write([]byte(`{"id":42,"name":"ada"}`))
        }))
    defer srv.Close()

    c := &Client{BaseURL: srv.URL, Token: "t"}
    u, err := c.FetchUser(context.Background(), 42)
    if err != nil {
        t.Fatal(err)
    }
    if u.Name != "ada" {
        t.Fatalf("want ada, got %s", u.Name)
    }
}

// Flag, then env, then YAML, then default. Repeated everywhere.
func loadPort() int {
    if v := flag.Lookup("port").Value.String(); v != "" {
        if n, err := strconv.Atoi(v); err == nil {
            return n
        }
    }
    if v := os.Getenv("APP_PORT"); v != "" {
        if n, err := strconv.Atoi(v); err == nil {
            return n
        }
    }
    var cfg struct{ Port int `yaml:"port"` }
    if b, err := os.ReadFile("app.yaml"); err == nil {
        _ = yaml.Unmarshal(b, &cfg)
        if cfg.Port != 0 {
            return cfg.Port
        }
    }
    return 8080
}