package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/fujin/anthropic-proxy/internal/auth"
	"github.com/fujin/anthropic-proxy/internal/config"
	"github.com/fujin/anthropic-proxy/internal/proxy"
	"github.com/fujin/anthropic-proxy/internal/server"
)

func run() error {
	log.SetFlags(log.LstdFlags)

	cfg, err := config.Load("config.yaml")
	if err != nil {
		return fmt.Errorf("load config: %w", err)
	}

	// Load credentials from ~/.claude/.credentials.json
	creds, err := config.LoadDefaultCredentials()
	if err != nil {
		return fmt.Errorf("load credentials: %w", err)
	}

	var cred *auth.Credential
	if len(creds) > 0 {
		cred = creds[0]
		// If token is expired, try refresh first
		if !cred.ExpiresAt.IsZero() && time.Now().After(cred.ExpiresAt) {
			log.Printf("token expired, attempting refresh...")
			refreshCtx, refreshCancel := context.WithTimeout(context.Background(), 15*time.Second)
			refreshErr := auth.RefreshToken(refreshCtx, cred)
			refreshCancel()
			if refreshErr != nil {
				log.Printf("refresh failed: %v — initiating login", refreshErr)
				cred = nil // fall through to login
			} else {
				log.Printf("token refreshed successfully")
			}
		}
	}

	if cred == nil {
		// Non-TTY check: if stdin is not a terminal, can't do interactive login
		fi, statErr := os.Stdin.Stat()
		if statErr == nil && (fi.Mode()&os.ModeCharDevice) == 0 {
			return fmt.Errorf("no valid credentials found; run the proxy interactively for initial login")
		}
		log.Printf("no valid credentials found, starting OAuth login flow...")
		cred, err = auth.Login(context.Background())
		if err != nil {
			return fmt.Errorf("login failed: %w", err)
		}
	}

	log.Printf("loaded credential for %s", cred.Email)

	pool := auth.NewPool([]*auth.Credential{cred})

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	pool.RefreshExpiring(context.Background())
	auth.StartBackgroundRefresh(ctx, pool)

	var profile *proxy.SniffedProfile
	if cfg.ClaudeBinary != "" {
		log.Printf("sniffing claude-code at %s...", cfg.ClaudeBinary)
		profile, err = proxy.SniffClaudeCode(cfg.ClaudeBinary)
		if err != nil {
			log.Printf("warning: sniff failed, using defaults: %v", err)
		}
	}

	log.Printf("starting server on port %d", cfg.Port)
	srv := server.New(cfg, pool, profile)

	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

	go func() {
		<-quit
		log.Printf("shutting down...")
		cancel()

		shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer shutdownCancel()

		if err := srv.Shutdown(shutdownCtx); err != nil {
			log.Printf("shutdown error: %v", err)
		}
	}()

	if err := srv.Start(); err != nil && err != http.ErrServerClosed {
		return err
	}

	return nil
}

func main() {
	if err := run(); err != nil {
		log.Printf("error: %v", err)
		os.Exit(1)
	}
}