app.go

package main

import (
	"context"
	"errors"
	"fmt"
	"net"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"sort"
	"strings"
	"sync"
	"sync/atomic"
	"time"

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

	"github.com/znsoftm/RapidProxy/internal/applog"
	"github.com/znsoftm/RapidProxy/internal/autostart"
	"github.com/znsoftm/RapidProxy/internal/config"
	"github.com/znsoftm/RapidProxy/internal/locale"
	"github.com/znsoftm/RapidProxy/internal/proxysrv"
	"github.com/znsoftm/RapidProxy/internal/store"
	"github.com/znsoftm/RapidProxy/internal/tray"
	"github.com/znsoftm/RapidProxy/internal/update"
	"github.com/znsoftm/RapidProxy/internal/upstream"
	"github.com/znsoftm/RapidProxy/internal/winfit"
)

// 事件名（前端通过 window.runtime.EventsOn 订阅）。
const (
	eventState  = "state"
	eventLogin  = "login"
	eventLog    = "log"
	eventUpdate = "update"
)

// Version 是程序版本号。
const Version = "1.2.4"

// 窗口尺寸（逻辑像素，与 Wails 的屏幕尺寸单位一致）。
//
// 这只是「期望值」，实际尺寸会在启动时按当前屏幕收敛，见 App.fitWindow。
const (
	windowDefaultWidth  = 1080
	windowDefaultHeight = 740
	windowMinWidth      = 940
	windowMinHeight     = 600
)

// -----------------------------------------------------------------------------
// 前端视图模型
// -----------------------------------------------------------------------------

// AccessView 是给用户复制到其它软件的接入信息。
type AccessView struct {
	BaseURL    string   `json:"baseUrl"`
	OpenAIURL  string   `json:"openaiUrl"`
	APIKeys    []string `json:"apiKeys"`
	RequireKey bool     `json:"requireKey"`
	Models     []string `json:"models"`
	Running    bool     `json:"running"`
	Sample     string   `json:"sample"`
}

// AccountView 是账号列表项。
type AccountView struct {
	ID           string `json:"id"`
	Provider     string `json:"provider"`
	ProviderName string `json:"providerName"`
	Nickname     string `json:"nickname"`
	UID          string `json:"uid"`
	EnterpriseID string `json:"enterpriseId"`
	ExpiresAt    string `json:"expiresAt"`
	ExpiresIn    string `json:"expiresIn"`
	Expired      bool   `json:"expired"`
	CreatedAt    string `json:"createdAt"`
}

// ProviderView 是上游配置项。
type ProviderView struct {
	ID           string `json:"id"`
	Name         string `json:"name"`
	Enabled      bool   `json:"enabled"`
	BaseURL      string `json:"baseUrl"`
	Origin       string `json:"origin"`
	Proxy        string `json:"proxy"`
	AccountCount int    `json:"accountCount"`
	ModelCount   int    `json:"modelCount"`
	NeedsProxy   bool   `json:"needsProxy"`
}

// ModelView 是模型列表项。
type ModelView struct {
	ID       string `json:"id"`
	Name     string `json:"name"`
	Provider string `json:"provider"`
	Context  int64  `json:"context"`
	MaxOut   int64  `json:"maxOut"`
	Images   bool   `json:"images"`
}

// SettingsView 是设置面板数据。
type SettingsView struct {
	Listen         string `json:"listen"`
	ModelSyncHours int    `json:"modelSyncHours"`
	CORS           bool   `json:"cors"`
	Sanitize       bool   `json:"sanitize"`
	MaxThinking    bool   `json:"maxThinking"`
	AutoStart      bool   `json:"autoStart"`
	LaunchAtLogin  bool   `json:"launchAtLogin"`
	// Language 是界面语言偏好：system / zh / en（前端据此渲染界面）。
	Language   string `json:"language"`
	ConfigPath string `json:"configPath"`
	DataDir    string `json:"dataDir"`
	LogPath    string `json:"logPath"`
	AccountDir string `json:"accountDir"`
	Version    string `json:"version"`
	Platform   string `json:"platform"`
}

// StateView 是界面一次拉取的全部状态。
type StateView struct {
	Running    bool           `json:"running"`
	Listen     string         `json:"listen"`
	BaseURL    string         `json:"baseUrl"`
	OpenAIURL  string         `json:"openaiUrl"`
	RequireKey bool           `json:"requireKey"`
	APIKeys    []string       `json:"apiKeys"`
	Providers  []ProviderView `json:"providers"`
	Accounts   []AccountView  `json:"accounts"`
	Models     []ModelView    `json:"models"`
	Settings   SettingsView   `json:"settings"`
	Logs       []string       `json:"logs"`
	Login      LoginView      `json:"login"`
}

// LoginView 是登录流程状态。
type LoginView struct {
	Active    bool   `json:"active"`
	Provider  string `json:"provider"`
	URL       string `json:"url"`
	EmbedURL  string `json:"embedUrl"`
	State     string `json:"state"`
	Status    string `json:"status"`
	Message   string `json:"message"`
	ExpiresAt string `json:"expiresAt"`
	AccountID string `json:"accountId"`
}

// UpdateView 是在线更新的检查结果与安装进度。
type UpdateView struct {
	Phase     string `json:"phase"` // idle / checking / available / none / downloading / installing / done / failed
	Current   string `json:"current"`
	Latest    string `json:"latest"`
	HasUpdate bool   `json:"hasUpdate"`
	Page      string `json:"page"`      // Release 页面
	AssetName string `json:"assetName"` // 将下载的安装包
	Notes     string `json:"notes"`     // Release 说明
	Progress  int    `json:"progress"`  // 0-100（下载时）
	Message   string `json:"message"`   // 给用户看的提示
}

// ProfileInput 是保存设置时的上游开关。
type ProfileInput struct {
	ID      string `json:"id"`
	Enabled bool   `json:"enabled"`
	Proxy   string `json:"proxy"`
}

// SettingsInput 是保存设置的入参。
type SettingsInput struct {
	Listen         string         `json:"listen"`
	ModelSyncHours int            `json:"modelSyncHours"`
	CORS           bool           `json:"cors"`
	Sanitize       bool           `json:"sanitize"`
	MaxThinking    bool           `json:"maxThinking"`
	AutoStart      bool           `json:"autoStart"`
	LaunchAtLogin  bool           `json:"launchAtLogin"`
	Profiles       []ProfileInput `json:"profiles"`
}

// -----------------------------------------------------------------------------
// App
// -----------------------------------------------------------------------------

type loginRun struct {
	provider     string
	session      *upstream.LoginSession
	cancel       context.CancelFunc
	status       string
	message      string
	accountID    string
	parentOrigin string
}

// App 是绑定给前端的应用对象。
type App struct {
	dataDir string

	ctx   context.Context
	ctxMu sync.RWMutex
	log   *applog.Logger
	store *store.Store
	srv   *proxysrv.Server
	tray  *tray.Tray

	cfgMu sync.RWMutex
	cfg   *config.Config

	quitting    atomic.Bool
	headless    atomic.Bool
	trayHint    atomic.Bool
	pendingShow atomic.Bool // 窗口就绪前收到的显示请求，startup 末尾补显
	unsubLog    func()
	loginMu     sync.Mutex
	login       *loginRun

	updMu sync.Mutex
	upd   *update.Release // 最近一次检查到的可用更新
}

// NewApp 初始化应用。
func NewApp() *App {
	dataDir := config.DefaultDataDir()
	if custom := strings.TrimSpace(os.Getenv("RAPIDPROXY_DATA_DIR")); custom != "" {
		dataDir = custom
	}

	logger := applog.New(dataDir, 800)

	cfgPath := config.DefaultPath(dataDir)
	cfg, err := config.Load(cfgPath)
	if err != nil {
		logger.Errorf("加载配置失败，使用默认配置: %v", err)
		// 带上路径，否则界面上的「配置文件路径」会是空的，保存时也会写到别处。
		cfg = config.DefaultAt(cfgPath)
	}
	// 界面语言尽早定下来：托盘菜单、更新提示等 Go 侧文案在窗口出现前后都会用到。
	locale.Set(locale.FromPref(cfg.Language))

	credStore, err := store.New(dataDir)
	if err != nil {
		logger.Errorf("初始化凭据仓库失败: %v", err)
	}

	app := &App{
		dataDir: dataDir,
		log:     logger,
		store:   credStore,
		cfg:     cfg,
	}
	app.srv = proxysrv.New(cfg, credStore, logger)
	return app
}

// startup 在窗口创建后调用。
func (a *App) startup(ctx context.Context) {
	a.ctxMu.Lock()
	a.ctx = ctx
	a.ctxMu.Unlock()

	a.log.Infof("RapidProxy %s 已启动（数据目录 %s）", Version, a.dataDir)
	a.unsubLog = a.log.Subscribe(func(line string) {
		a.emit(eventLog, line)
	})

	// 按配置同步系统自启动条目：既是首次启用的默认值落位，
	// 也是程序升级（安装路径变化）后自动修正自启动指向。
	a.applyLaunchAtLogin(a.cfg.LaunchAtLoginEnabled())
	// 在界面真正显示出来之前收敛窗口尺寸（见 fitWindow 的注释）。
	a.fitWindow(ctx)

	if a.cfg.AutoStartEnabled() {
		if err := a.StartService(); err != nil {
			a.log.Errorf("自动启动失败: %v", err)
		}
	}
	a.pushState()

	// 启动期间收到的激活请求（第二份程序抢在窗口就绪前启动了本实例）
	// 在这里补上：窗口几何已在 fitWindow 收敛完毕，直接显示即可。
	if a.pendingShow.CompareAndSwap(true, false) {
		wailsrt.WindowShow(ctx)
	}

	// 后台静默检查一次更新（失败不打扰用户，结果通过 update 事件推送）
	go func() {
		time.Sleep(4 * time.Second)
		if a.quitting.Load() {
			return
		}
		client := &http.Client{Timeout: 20 * time.Second}
		ctx, cancel := context.WithTimeout(context.Background(), 25*time.Second)
		defer cancel()
		if rel, has, err := update.Check(ctx, client, "", update.DefaultRepo, Version); err == nil && has {
			a.updMu.Lock()
			a.upd = rel
			a.updMu.Unlock()
			a.emitUpdate(UpdateView{
				Phase: "available", Current: Version, Latest: rel.Version,
				HasUpdate: true, Page: rel.Page, AssetName: rel.Asset.Name, Notes: rel.Notes,
				Message: locale.T("upd.availableSettings", rel.Version),
			})
		}
	}()
}

func (a *App) context() context.Context {
	a.ctxMu.RLock()
	defer a.ctxMu.RUnlock()
	return a.ctx
}

func (a *App) emit(name string, payload any) {
	ctx := a.context()
	if ctx == nil {
		return
	}
	wailsrt.EventsEmit(ctx, name, payload)
}

func (a *App) pushState() { a.emit(eventState, a.GetState()) }

func (a *App) pushLogin() { a.emit(eventLogin, a.loginState()) }

func (a *App) settings() *config.Config {
	a.cfgMu.RLock()
	defer a.cfgMu.RUnlock()
	return a.cfg
}

// startTray 初始化托盘图标（必须在 wails.Run 之前调用）。
func (a *App) startTray() {
	a.tray = tray.Start(tray.Callbacks{
		OnShow:        a.ShowWindow,
		OnResetWindow: a.ResetWindow,
		OnToggle:      a.ToggleService,
		OnCopyURL: func() {
			ctx := a.context()
			if ctx == nil {
				return
			}
			url := a.settings().OpenAIBaseURL()
			wailsrt.ClipboardSetText(ctx, url)
			a.log.Infof("已复制接口地址: %s", url)
		},
		OnQuit: a.QuitApp,
	})
	a.syncTray()
}

func (a *App) syncTray() {
	if a.tray == nil {
		return
	}
	running := false
	addr := a.settings().Listen
	if a.srv != nil {
		running = a.srv.Running()
		addr = a.srv.Addr()
	}
	a.tray.SetState(running, addr)
}

// beforeClose 拦截窗口关闭：默认只最小化到托盘，退出只能通过托盘菜单。
func (a *App) beforeClose(ctx context.Context) bool {
	if a.quitting.Load() {
		return false
	}
	wailsrt.WindowHide(ctx)
	a.log.Infof("窗口已最小化到系统托盘（右键托盘图标可退出）")
	go a.hintTrayOnce(ctx)
	return true
}

func (a *App) hintTrayOnce(ctx context.Context) {
	if !a.trayHint.CompareAndSwap(false, true) {
		return
	}
	_, _ = wailsrt.MessageDialog(ctx, wailsrt.MessageDialogOptions{
		Type:    wailsrt.InfoDialog,
		Title:   locale.T("dlg.minimized.title"),
		Message: locale.T("dlg.minimized.msg"),
		Buttons: []string{locale.T("dlg.minimized.ok")},
	})
}

// -----------------------------------------------------------------------------
// 窗口尺寸自适应
// -----------------------------------------------------------------------------

// fitWindow 在启动时把主窗口收敛到当前屏幕的可见范围内。
//
// 为什么需要：Wails 窗口的宽高是「逻辑像素」，创建窗口时会按屏幕 DPI 换算成
// 物理像素。系统缩放 150% 时，逻辑高度 740 会被放大成 1110 物理像素，在
// 1920x1080 的屏幕上就超出了屏幕高度，窗口上下都会跑到屏幕外看不到。所以在
// 窗口显示之前按屏幕（逻辑）尺寸重新算一遍尺寸并居中。
func (a *App) fitWindow(ctx context.Context) {
	preferred := winfit.Size{Width: windowDefaultWidth, Height: windowDefaultHeight}
	floorMin := winfit.Size{Width: windowMinWidth, Height: windowMinHeight}

	screen, physical, ok := currentScreenSize(ctx)
	if !ok {
		a.log.Warnf("未能读取屏幕尺寸，窗口保持默认尺寸 %dx%d", preferred.Width, preferred.Height)
		wailsrt.WindowSetMinSize(ctx, floorMin.Width, floorMin.Height)
		wailsrt.WindowSetSize(ctx, preferred.Width, preferred.Height)
		wailsrt.WindowCenter(ctx)
		return
	}

	size, min := winfit.Fit(preferred, floorMin, screen)

	// 先设最小尺寸再设实际尺寸：Wails 在设置尺寸时会用最小尺寸做钳制，
	// 屏幕比默认最小尺寸还小时必须先放宽下限，否则窗口压不下去。
	wailsrt.WindowSetMinSize(ctx, min.Width, min.Height)
	wailsrt.WindowSetSize(ctx, size.Width, size.Height)
	wailsrt.WindowCenter(ctx)

	desc := screenDesc(screen, physical)
	if size != preferred {
		a.log.Infof("屏幕 %s，窗口尺寸收敛为 %dx%d（最小 %dx%d）",
			desc, size.Width, size.Height, min.Width, min.Height)
		return
	}
	a.log.Infof("屏幕 %s，窗口尺寸 %dx%d", desc, size.Width, size.Height)
}

// currentScreenSize 返回主窗口所在屏幕的逻辑尺寸（含任务栏区域）。
//
// 优先取「窗口所在屏幕」，其次主屏，最后任意一块可用屏幕。取不到时返回 false，
// 调用方保持默认尺寸。第二个返回值是屏幕的物理尺寸，仅用于日志。
func currentScreenSize(ctx context.Context) (winfit.Size, winfit.Size, bool) {
	empty := winfit.Size{}
	screens, err := wailsrt.ScreenGetAll(ctx)
	if err != nil || len(screens) == 0 {
		return empty, empty, false
	}

	usable := func(i int) bool {
		return screens[i].Size.Width > 0 && screens[i].Size.Height > 0
	}

	pick := -1
	for i := range screens {
		if usable(i) && screens[i].IsCurrent {
			pick = i
			break
		}
	}
	if pick < 0 {
		for i := range screens {
			if usable(i) && screens[i].IsPrimary {
				pick = i
				break
			}
		}
	}
	if pick < 0 {
		for i := range screens {
			if usable(i) {
				pick = i
				break
			}
		}
	}
	if pick < 0 {
		return empty, empty, false
	}

	s := screens[pick]
	return winfit.Size{Width: s.Size.Width, Height: s.Size.Height},
		winfit.Size{Width: s.PhysicalSize.Width, Height: s.PhysicalSize.Height},
		true
}

// screenDesc 生成形如「2560x1440（物理 3840x2160，缩放 150%）」的描述，仅用于日志。
func screenDesc(logical, physical winfit.Size) string {
	desc := fmt.Sprintf("%dx%d", logical.Width, logical.Height)
	if physical.Width <= 0 || physical.Height <= 0 || logical.Width <= 0 {
		return desc
	}
	scale := float64(physical.Width) / float64(logical.Width) * 100
	if int(scale+0.5) == 100 {
		return desc
	}
	return fmt.Sprintf("%s（物理 %dx%d，缩放 %d%%）", desc, physical.Width, physical.Height, int(scale+0.5))
}

// ResetWindow 把窗口重新收敛到当前屏幕并居中。
//
// 用途：窗口被拖到已拔掉的显示器上、或系统改过缩放比例后跑到屏幕外时，
// 从托盘菜单一键恢复。前端也可以直接调用。
func (a *App) ResetWindow() {
	ctx := a.context()
	if ctx == nil {
		return
	}
	go func() {
		a.fitWindow(ctx)
		a.ShowWindow()
	}()
}

// -----------------------------------------------------------------------------
// 窗口 / 生命周期（供前端调用）
// -----------------------------------------------------------------------------

// ShowWindow 显示主窗口。
func (a *App) ShowWindow() {
	ctx := a.context()
	if ctx == nil {
		return
	}
	wailsrt.WindowUnminimise(ctx)
	wailsrt.WindowShow(ctx)
	a.pendingShow.Store(false)
}

// HandleSecondInstance 处理后续实例的激活请求：把主窗口带到前台。
//
// 第二份程序启动时发现已有实例，会通过 singleton 包通知本实例。若通知到达
// 时窗口尚未创建完（ctx 为空），请求会被记住，startup 末尾再补一次显示。
func (a *App) HandleSecondInstance() {
	a.pendingShow.Store(true)
	a.ShowWindow()
}

// HideWindow 隐藏主窗口到托盘。
func (a *App) HideWindow() {
	ctx := a.context()
	if ctx == nil {
		return
	}
	wailsrt.WindowHide(ctx)
}

// QuitApp 完全退出程序。
func (a *App) QuitApp() {
	a.quitting.Store(true)
	a.log.Infof("正在退出 RapidProxy")
	if err := a.StopService(); err != nil {
		a.log.Warnf("停止服务时出错: %v", err)
	}
	a.cancelLogin()
	a.log.Close()
	if a.tray != nil {
		a.tray.Quit()
	}
	if a.headless.Load() {
		// 后台模式下没有 Wails 事件循环，直接结束进程。
		os.Exit(0)
	}
	if ctx := a.context(); ctx != nil {
		wailsrt.Quit(ctx)
		return
	}
	os.Exit(0)
}

// runHeadless 在界面不可用时退化为后台服务，仅保留托盘与 OpenAI 接口。
func (a *App) runHeadless() {
	a.headless.Store(true)
	if err := a.StartService(); err != nil {
		a.log.Errorf("后台模式启动代理服务失败: %v", err)
		os.Exit(1)
	}
	a.log.Infof("已进入后台模式（无界面）：接口地址 %s，可从托盘图标退出", a.settings().OpenAIBaseURL())
	select {}
}

// -----------------------------------------------------------------------------
// 状态
// -----------------------------------------------------------------------------

// GetState 返回界面所需的完整状态。
func (a *App) GetState() StateView {
	cfg := a.settings()
	view := StateView{
		Running:    a.srv.Running(),
		Listen:     cfg.Listen,
		BaseURL:    cfg.BaseURL(),
		OpenAIURL:  cfg.OpenAIBaseURL(),
		RequireKey: cfg.RequiresAPIKey(),
		APIKeys:    append([]string(nil), cfg.APIKeys...),
		Logs:       a.log.Tail(200),
		Login:      a.loginState(),
	}
	if addr := a.srv.Addr(); addr != "" {
		view.Listen = addr
	}
	// 凭据目录只读一次，供上游列表与账号列表共用（每次 GetState 都会被调用）。
	creds, _ := a.store.List("")
	view.Providers = a.providerViews(creds)
	view.Accounts = a.accountViews(creds)
	view.Models = a.modelViews()
	view.Settings = SettingsView{
		Listen:         cfg.Listen,
		ModelSyncHours: cfg.ModelSyncHours,
		CORS:           cfg.CORSEnabled(),
		Sanitize:       cfg.SanitizeEnabled(),
		MaxThinking:    cfg.MaxThinkingEnabled(),
		AutoStart:      cfg.AutoStartEnabled(),
		LaunchAtLogin:  cfg.LaunchAtLoginEnabled(),
		Language:       cfg.Language,
		ConfigPath:     cfg.Path(),
		DataDir:        a.dataDir,
		LogPath:        a.log.FilePath(),
		AccountDir:     a.store.Root(),
		Version:        Version,
		Platform:       runtime.GOOS + "/" + runtime.GOARCH,
	}
	return view
}

// GetAccessInfo 返回给用户复制到其它软件的接入信息。
func (a *App) GetAccessInfo() AccessView {
	cfg := a.settings()
	models := a.srv.ModelIDs()
	requireKey := cfg.RequiresAPIKey()
	key := "<你的 API Key>"
	if !requireKey {
		key = "sk-any"
	} else if len(cfg.APIKeys) > 0 {
		key = cfg.APIKeys[0]
	}
	sample := fmt.Sprintf(
		"curl %s/chat/completions \\\n  -H \"Content-Type: application/json\" \\\n  -H \"Authorization: Bearer %s\" \\\n  -d '{\"model\":\"%s\",\"messages\":[{\"role\":\"user\",\"content\":\"你好\"}],\"stream\":true}'",
		cfg.OpenAIBaseURL(), key, firstModel(models),
	)
	return AccessView{
		BaseURL:    cfg.BaseURL(),
		OpenAIURL:  cfg.OpenAIBaseURL(),
		APIKeys:    append([]string(nil), cfg.APIKeys...),
		RequireKey: requireKey,
		Models:     models,
		Running:    a.srv.Running(),
		Sample:     sample,
	}
}

func firstModel(models []string) string {
	if len(models) == 0 {
		return "gpt-5.4"
	}
	return models[0]
}

func (a *App) providerViews(creds []*upstream.Credential) []ProviderView {
	cfg := a.settings()
	counts := map[string]int{}
	for _, c := range creds {
		counts[c.Provider]++
	}
	out := make([]ProviderView, 0, len(cfg.Profiles))
	for _, p := range cfg.Profiles {
		out = append(out, ProviderView{
			ID:           p.ID,
			Name:         p.Name,
			Enabled:      p.Enabled,
			BaseURL:      p.BaseURL,
			Origin:       p.Origin,
			Proxy:        p.Proxy,
			AccountCount: counts[p.ID],
			ModelCount:   len(a.srv.ModelsFor(p.ID)),
			NeedsProxy:   strings.Contains(p.BaseURL, "workbuddy.ai"),
		})
	}
	return out
}

func (a *App) accountViews(creds []*upstream.Credential) []AccountView {
	cfg := a.settings()
	names := map[string]string{}
	for _, p := range cfg.Profiles {
		names[p.ID] = p.Name
	}
	out := make([]AccountView, 0, len(creds))
	for _, c := range creds {
		expiresAt := c.ExpiresAtTime()
		view := AccountView{
			ID:           c.ID,
			Provider:     c.Provider,
			ProviderName: names[c.Provider],
			Nickname:     c.DisplayName(),
			UID:          c.Account.UID,
			EnterpriseID: c.Account.EnterpriseID,
			Expired:      c.Expired(),
		}
		if view.ProviderName == "" {
			view.ProviderName = c.Provider
		}
		if !expiresAt.IsZero() {
			view.ExpiresAt = expiresAt.Format("2006-01-02 15:04")
			view.ExpiresIn = humanDuration(time.Until(expiresAt))
		}
		if !c.CreatedAt.IsZero() {
			view.CreatedAt = c.CreatedAt.Format("2006-01-02 15:04")
		}
		out = append(out, view)
	}
	sort.SliceStable(out, func(i, j int) bool {
		if out[i].Provider != out[j].Provider {
			return out[i].Provider < out[j].Provider
		}
		return out[i].CreatedAt < out[j].CreatedAt
	})
	return out
}

func (a *App) modelViews() []ModelView {
	cfg := a.settings()
	names := map[string]string{}
	for _, p := range cfg.Profiles {
		names[p.ID] = p.Name
	}
	models := a.srv.AllModels()
	out := make([]ModelView, 0, len(models))
	for _, m := range models {
		out = append(out, ModelView{
			ID:       m.ID,
			Name:     m.DisplayName,
			Provider: names[m.Provider],
			Context:  m.ContextLength,
			MaxOut:   m.MaxOutputTokens,
			Images:   m.SupportsImages,
		})
	}
	return out
}

// GetLogs 返回最近日志。
func (a *App) GetLogs() []string { return a.log.Tail(300) }

// ClearLogs 清空界面上的日志。
func (a *App) ClearLogs() {
	a.log.Clear()
	a.pushState()
}

// -----------------------------------------------------------------------------
// 服务控制
// -----------------------------------------------------------------------------

// StartService 启动代理服务。
func (a *App) StartService() error {
	if err := a.srv.Start(); err != nil {
		a.log.Errorf("启动服务失败: %v", err)
		a.syncTray()
		a.pushState()
		return err
	}
	a.syncTray()
	a.pushState()
	return nil
}

// StopService 停止代理服务。
func (a *App) StopService() error {
	err := a.srv.Stop()
	a.syncTray()
	a.pushState()
	return err
}

// ToggleService 切换服务启停，返回切换后的状态。
func (a *App) ToggleService() bool {
	if a.srv.Running() {
		_ = a.StopService()
	} else {
		_ = a.StartService()
	}
	return a.srv.Running()
}

// RestartService 重启服务（监听地址变更后使用）。
func (a *App) RestartService() error {
	if err := a.StopService(); err != nil {
		a.log.Warnf("停止服务失败: %v", err)
	}
	return a.StartService()
}

// RefreshModels 立即从上游同步模型列表。
func (a *App) RefreshModels() error {
	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()
	a.srv.RefreshModels(ctx)
	a.pushState()
	return nil
}

// -----------------------------------------------------------------------------
// API Key
// -----------------------------------------------------------------------------

// GenerateAPIKey 生成并保存一个新的 API Key。
func (a *App) GenerateAPIKey() (string, error) {
	key := config.GenerateAPIKey()
	if err := a.AddAPIKey(key); err != nil {
		return "", err
	}
	return key, nil
}

// AddAPIKey 添加一个自定义 API Key。
func (a *App) AddAPIKey(key string) error {
	key = strings.TrimSpace(key)
	if key == "" {
		return errors.New(locale.T("key.empty"))
	}
	cfg := a.settings().Clone()
	if !cfg.AddAPIKey(key) {
		return errors.New(locale.T("key.duplicate"))
	}
	if err := cfg.Save(); err != nil {
		return err
	}
	a.cfgMu.Lock()
	a.cfg = cfg
	a.cfgMu.Unlock()
	a.srv.SetConfig(cfg)
	a.log.Infof("已设置 API Key（%s）", maskKey(key))
	a.pushState()
	return nil
}

// RemoveAPIKey 删除一个 API Key。
func (a *App) RemoveAPIKey(key string) error {
	cfg := a.settings().Clone()
	if !cfg.RemoveAPIKey(key) {
		return errors.New(locale.T("key.notFound"))
	}
	if err := cfg.Save(); err != nil {
		return err
	}
	a.cfgMu.Lock()
	a.cfg = cfg
	a.cfgMu.Unlock()
	a.srv.SetConfig(cfg)
	a.log.Infof("已删除 API Key（%s）", maskKey(key))
	a.pushState()
	return nil
}

func maskKey(key string) string {
	// 注意：key 由用户在界面上输入，长度不可信，短 key 不能越界切片。
	switch {
	case len(key) <= 2:
		return "****"
	case len(key) <= 12:
		return key[:2] + "****"
	default:
		return key[:10] + "****" + key[len(key)-4:]
	}
}

// -----------------------------------------------------------------------------
// 账号与登录
// -----------------------------------------------------------------------------

// StartLogin 发起某个上游的登录流程。parentOrigin 是前端页面自己的 origin
// （如 http://wails.localhost），用于构造应用内 iframe 授权链接；传空则只返回外部浏览器链接。
func (a *App) StartLogin(provider, parentOrigin string) (LoginView, error) {
	cfg := a.settings()
	profile, ok := cfg.ProfileByID(provider)
	if !ok {
		return LoginView{}, fmt.Errorf("%s", locale.T("login.unknownProvider", provider))
	}
	client, err := a.srv.ClientFor(provider)
	if err != nil {
		return LoginView{}, err
	}

	a.cancelLogin()

	ctx, cancel := context.WithTimeout(context.Background(), 6*time.Minute)
	session, err := client.StartLogin(ctx)
	if err != nil {
		cancel()
		a.log.Errorf("[%s] 发起登录失败: %v", profile.Name, err)
		return LoginView{}, err
	}

	run := &loginRun{
		provider:     provider,
		session:      session,
		cancel:       cancel,
		status:       "pending",
		message:      locale.T("login.browserOpened"),
		parentOrigin: strings.TrimSpace(parentOrigin),
	}
	a.loginMu.Lock()
	a.login = run
	a.loginMu.Unlock()

	// 内嵌 iframe 授权页会被上游安全策略（X-Frame-Options / CSP frame-ancestors）
	// 拦截，无法在应用内显示；统一改用系统浏览器完成登录。
	// 登录结果仍由后端轮询自动感知，不依赖浏览器回调。
	if ctx := a.context(); ctx != nil {
		wailsrt.BrowserOpenURL(ctx, session.AuthURL)
		a.log.Infof("[%s] 已在系统浏览器打开登录页", profile.Name)
	} else {
		a.log.Warnf("[%s] 无法自动打开浏览器，请复制登录链接手动访问", profile.Name)
	}
	a.pushLogin()

	go a.pollLogin(ctx, run)
	return a.loginState(), nil
}

func (a *App) pollLogin(ctx context.Context, run *loginRun) {
	ticker := time.NewTicker(2 * time.Second)
	defer ticker.Stop()
	for {
		select {
		case <-ctx.Done():
			a.finishLogin(run, "failed", locale.T("login.timeout"), "")
			return
		case <-ticker.C:
			cred, err := run.session.Poll(ctx)
			if err != nil {
				if errors.Is(err, upstream.ErrLoginTimeout) {
					a.finishLogin(run, "failed", locale.T("login.expired"), "")
					return
				}
				a.finishLogin(run, "failed", err.Error(), "")
				return
			}
			if cred == nil {
				continue
			}
			if err := a.store.Save(cred); err != nil {
				a.finishLogin(run, "failed", locale.T("login.saveFailed", err.Error()), "")
				return
			}
			a.log.Infof("登录成功: %s（%s）", cred.DisplayName(), cred.ID)
			a.finishLogin(run, "success", locale.T("login.success"), cred.ID)
			go func() {
				refreshCtx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
				defer cancel()
				a.srv.RefreshModels(refreshCtx)
				a.pushState()
			}()
			return
		}
	}
}

func (a *App) finishLogin(run *loginRun, status, message, accountID string) {
	a.loginMu.Lock()
	if a.login == run {
		run.status = status
		run.message = message
		run.accountID = accountID
		if status != "pending" {
			run.cancel()
		}
	}
	a.loginMu.Unlock()
	a.log.Infof("登录流程结束: %s", message)
	a.pushLogin()
	a.pushState()
}

func (a *App) cancelLogin() {
	a.loginMu.Lock()
	run := a.login
	a.login = nil
	a.loginMu.Unlock()
	if run != nil && run.cancel != nil {
		run.cancel()
	}
}

// CancelLogin 取消当前登录流程。
func (a *App) CancelLogin() {
	a.cancelLogin()
	a.log.Infof("已取消登录")
	a.pushLogin()
}

func (a *App) loginState() LoginView {
	a.loginMu.Lock()
	defer a.loginMu.Unlock()
	if a.login == nil {
		return LoginView{Status: "idle"}
	}
	run := a.login
	view := LoginView{
		Active:    run.status == "pending",
		Provider:  run.provider,
		URL:       run.session.AuthURL,
		EmbedURL:  run.session.EmbeddedAuthURL(run.parentOrigin),
		State:     run.session.State,
		Status:    run.status,
		Message:   run.message,
		ExpiresAt: run.session.ExpiresAt.Format("15:04:05"),
		AccountID: run.accountID,
	}
	return view
}

// DeleteAccount 删除一个账号。
func (a *App) DeleteAccount(provider, id string) error {
	if err := a.store.Delete(provider, id); err != nil {
		return err
	}
	a.log.Infof("已删除账号 %s", id)
	a.pushState()
	return nil
}

// -----------------------------------------------------------------------------
// 设置
// -----------------------------------------------------------------------------

// SaveSettings 保存设置并立即生效（监听地址变更时自动重启服务）。
func (a *App) SaveSettings(input SettingsInput) error {
	cfg := a.settings().Clone()

	if v := strings.TrimSpace(input.Listen); v != "" {
		cfg.Listen = v
	}
	cfg.ModelSyncHours = input.ModelSyncHours
	cfg.CORS = boolPtr(input.CORS)
	cfg.SanitizeTemplates = boolPtr(input.Sanitize)
	cfg.ForceMaxThinking = boolPtr(input.MaxThinking)
	cfg.AutoStart = boolPtr(input.AutoStart)
	cfg.LaunchAtLogin = boolPtr(input.LaunchAtLogin)

	for _, in := range input.Profiles {
		profile, ok := cfg.ProfileByID(in.ID)
		if !ok {
			continue
		}
		profile.Enabled = in.Enabled
		profile.Proxy = strings.TrimSpace(in.Proxy)
		cfg.SetProfile(profile)
	}
	cfg.Normalize()

	if err := cfg.Save(); err != nil {
		a.log.Errorf("保存设置失败: %v", err)
		return err
	}
	a.cfgMu.Lock()
	a.cfg = cfg
	a.cfgMu.Unlock()
	a.srv.SetConfig(cfg)

	a.log.Infof("设置已保存（监听 %s，上游 %d 个）", cfg.Listen, len(cfg.EnabledProfiles()))

	// 开机自启动立即生效（注册 / 注销系统条目）。
	a.applyLaunchAtLogin(cfg.LaunchAtLoginEnabled())

	if a.srv.Running() {
		if !sameListenAddr(cfg.Listen, a.srv.Addr()) {
			// 只有监听地址真的变了才重启，否则 ":8787" 与 "[::]:8787"
			// 这种等价写法会导致每次保存都重启一次服务。
			if err := a.RestartService(); err != nil {
				a.pushState()
				return err
			}
		} else {
			go func() {
				ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
				defer cancel()
				a.srv.RefreshModels(ctx)
				a.pushState()
			}()
		}
	}
	a.pushState()
	return nil
}

func boolPtr(v bool) *bool { return &v }

// applyLaunchAtLogin 把开机自启动设置落到系统（失败只记日志，不影响主流程）。
func (a *App) applyLaunchAtLogin(enable bool) {
	if err := autostart.Set(enable); err != nil {
		a.log.Warnf("设置开机自启动（%v）失败: %v", enable, err)
		return
	}
	a.log.Infof("开机自启动已%s", boolText(enable))
}

func boolText(v bool) string {
	if v {
		return "开启"
	}
	return "关闭"
}

// sameListenAddr 判断两个监听地址是否等价。
//
// "" / "0.0.0.0" / "::" 都表示监听所有网卡，实际绑定后会变成 "[::]:端口"，
// 直接字符串比较会误判成地址变更。
func sameListenAddr(a, b string) bool {
	if a == b {
		return true
	}
	hostA, portA, errA := net.SplitHostPort(a)
	hostB, portB, errB := net.SplitHostPort(b)
	if errA != nil || errB != nil || portA != portB {
		return false
	}
	return hostA == hostB || (isAnyHost(hostA) && isAnyHost(hostB))
}

func isAnyHost(host string) bool {
	switch host {
	case "", "0.0.0.0", "::", "[::]":
		return true
	}
	return false
}

// -----------------------------------------------------------------------------
// 系统交互
// -----------------------------------------------------------------------------

// OpenURL 用系统默认浏览器打开链接。
func (a *App) OpenURL(url string) {
	ctx := a.context()
	if ctx == nil || strings.TrimSpace(url) == "" {
		return
	}
	wailsrt.BrowserOpenURL(ctx, url)
}

// CopyText 复制文本到剪贴板。
func (a *App) CopyText(text string) {
	ctx := a.context()
	if ctx == nil {
		return
	}
	wailsrt.ClipboardSetText(ctx, text)
}

// -----------------------------------------------------------------------------
// 在线更新
// -----------------------------------------------------------------------------

// emitUpdate 向前端推送更新进度。
func (a *App) emitUpdate(v UpdateView) {
	a.emit(eventUpdate, v)
}

// CheckUpdate 检查 GitHub 上的新版本。有更新时结果会被记住，供 DoUpdate 使用。
func (a *App) CheckUpdate() (UpdateView, error) {
	view := UpdateView{Phase: "checking", Current: Version}
	a.emitUpdate(view)

	client := &http.Client{Timeout: 20 * time.Second}
	ctx, cancel := context.WithTimeout(context.Background(), 25*time.Second)
	defer cancel()

	rel, has, err := update.Check(ctx, client, "", update.DefaultRepo, Version)
	if err != nil {
		view.Phase, view.Message = "failed", err.Error()
		a.emitUpdate(view)
		return view, err
	}

	view.Latest = rel.Version
	view.Page = rel.Page
	view.Notes = rel.Notes
	if !has {
		a.updMu.Lock()
		a.upd = nil
		a.updMu.Unlock()
		view.Phase, view.Message = "none", locale.T("upd.latest")
		a.emitUpdate(view)
		return view, nil
	}

	a.updMu.Lock()
	a.upd = rel
	a.updMu.Unlock()
	view.Phase = "available"
	view.HasUpdate = true
	view.AssetName = rel.Asset.Name
	view.Message = locale.T("upd.available", rel.Version, rel.Asset.Name)
	a.log.Infof("检查到新版本 v%s（当前 %s）", rel.Version, Version)
	a.emitUpdate(view)
	return view, nil
}

// DoUpdate 下载安装包并执行安装，随后退出当前程序。
//
//   - Windows：运行 NSIS 安装向导后退出
//   - macOS：用 open 打开 PKG 安装器后退出
//   - Linux：把新 AppImage 原地替换当前程序后自动重启；非 AppImage 运行方式
//     则把安装包放到数据目录并提示手动运行
func (a *App) DoUpdate() error {
	a.updMu.Lock()
	rel := a.upd
	a.updMu.Unlock()
	if rel == nil {
		return fmt.Errorf("%s", locale.T("upd.checkFirst"))
	}

	dest := filepath.Join(a.dataDir, "update", rel.Asset.Name)
	a.emitUpdate(UpdateView{
		Phase: "downloading", Current: Version, Latest: rel.Version,
		AssetName: rel.Asset.Name, Progress: -1,
		Message: locale.T("upd.downloadStart", rel.Asset.Name),
	})

	err := update.Download(context.Background(), nil, rel.Asset, dest, func(done, total int64) {
		pct := -1
		if total > 0 {
			pct = int(done * 100 / total)
		}
		a.emitUpdate(UpdateView{
			Phase: "downloading", Current: Version, Latest: rel.Version,
			AssetName: rel.Asset.Name, Progress: pct,
			Message: locale.T("upd.downloading", humanBytes(done), humanBytes(total)),
		})
	})
	if err != nil {
		a.log.Errorf("下载更新失败: %v", err)
		a.emitUpdate(UpdateView{Phase: "failed", Current: Version, Latest: rel.Version, Message: locale.T("upd.downloadFailed", err.Error())})
		return err
	}
	a.log.Infof("更新包已下载: %s", dest)

	if runtime.GOOS == "linux" {
		return a.applyLinuxUpdate(rel, dest)
	}

	a.emitUpdate(UpdateView{Phase: "installing", Current: Version, Latest: rel.Version, Message: locale.T("upd.launching")})
	a.log.Infof("启动安装程序: %s", dest)
	if err := update.LaunchInstaller(dest); err != nil {
		a.log.Errorf("启动安装程序失败: %v", err)
		a.emitUpdate(UpdateView{Phase: "failed", Current: Version, Latest: rel.Version, Message: locale.T("upd.launchFailed", err.Error())})
		return err
	}
	a.log.Infof("安装程序已启动，程序即将退出")
	a.QuitApp()
	return nil
}

// applyLinuxUpdate 处理 Linux 平台的更新：AppImage 原地替换并重启。
func (a *App) applyLinuxUpdate(rel *update.Release, dest string) error {
	exe, err := os.Executable()
	if err == nil {
		exe, err = filepath.EvalSymlinks(exe)
	}
	if err == nil && strings.EqualFold(filepath.Ext(exe), ".appimage") {
		a.emitUpdate(UpdateView{Phase: "installing", Current: Version, Latest: rel.Version, Message: locale.T("upd.replacingAppImage")})
		if err := os.Chmod(dest, 0o755); err != nil {
			a.emitUpdate(UpdateView{Phase: "failed", Current: Version, Message: locale.T("upd.chmodFailed", err.Error())})
			return err
		}
		if err := os.Rename(dest, exe); err != nil {
			a.emitUpdate(UpdateView{Phase: "failed", Current: Version, Message: locale.T("upd.replaceFailed", err.Error())})
			return err
		}
		a.log.Infof("AppImage 已替换为 v%s，正在重启", rel.Version)
		a.emitUpdate(UpdateView{Phase: "done", Current: rel.Version, Latest: rel.Version, Message: locale.T("upd.doneRestarting")})
		if err := exec.Command(exe).Start(); err != nil {
			a.log.Warnf("自动重启失败，请手动启动: %v", err)
		}
		a.QuitApp()
		return nil
	}

	// 非 AppImage 运行方式（如源码/压缩包运行）：交给用户手动安装
	a.emitUpdate(UpdateView{
		Phase: "done", Current: Version, Latest: rel.Version,
		Message: locale.T("upd.manualInstall", dest),
	})
	return nil
}

// humanBytes 把字节数格式化为可读文本。
func humanBytes(n int64) string {
	if n < 0 {
		return "?"
	}
	const unit = 1024
	if n < unit {
		return fmt.Sprintf("%d B", n)
	}
	div, exp := int64(unit), 0
	for m := n / unit; m >= unit; m /= unit {
		div *= unit
		exp++
	}
	return fmt.Sprintf("%.1f %cB", float64(n)/float64(div), "KMGTPE"[exp])
}

// OpenDataDir 打开数据目录（配置文件与凭据所在位置）。
func (a *App) OpenDataDir() {
	dir := a.dataDir
	var cmd *exec.Cmd
	switch runtime.GOOS {
	case "windows":
		cmd = exec.Command("explorer", filepath.Clean(dir))
	case "darwin":
		cmd = exec.Command("open", dir)
	default:
		cmd = exec.Command("xdg-open", dir)
	}
	if err := cmd.Start(); err != nil {
		a.log.Warnf("打开数据目录失败: %v", err)
	}
}

func humanDuration(d time.Duration) string {
	if d <= 0 {
		return locale.T("dur.expired")
	}
	days := int(d.Hours()) / 24
	hours := int(d.Hours()) % 24
	minutes := int(d.Minutes()) % 60
	switch {
	case days > 0:
		return locale.T("dur.dayHour", days, hours)
	case hours > 0:
		return locale.T("dur.hourMin", hours, minutes)
	default:
		return locale.T("dur.minute", minutes)
	}
}

// -----------------------------------------------------------------------------
// 语言
// -----------------------------------------------------------------------------

// SetLanguage 切换界面语言（system / zh / en）。
//
// 立即写回配置并刷新托盘菜单文案；前端收到新的 state 后会同步整页翻译。
// 返回解析后的实际语言（zh / en），供前端直接应用翻译。
func (a *App) SetLanguage(lang string) (string, error) {
	v := strings.ToLower(strings.TrimSpace(lang))
	switch v {
	case locale.PrefSystem, locale.PrefZh, locale.PrefEn:
	default:
		return "", errors.New(locale.T("lang.invalid", lang))
	}

	cfg := a.settings().Clone()
	cfg.Language = v
	if err := cfg.Save(); err != nil {
		a.log.Errorf("保存语言设置失败: %v", err)
		return "", err
	}
	a.cfgMu.Lock()
	a.cfg = cfg
	a.cfgMu.Unlock()

	locale.Set(locale.FromPref(v))
	if a.tray != nil {
		a.tray.Retitle()
	}
	a.log.Infof("界面语言已切换为 %s", locale.Current())
	a.pushState()
	return string(locale.Current()), nil
}