navi/internal/core/manager.go

package core

import (
	"context"
	"errors"
	"fmt"
	"io"
	"net"
	"net/http"
	"net/url"
	"os"
	"strings"
	"sync"
	"time"

	"vpnclient/internal/config"
	"vpnclient/internal/linknorm"
	"vpnclient/internal/protocols/awg"
	"vpnclient/internal/protocols/hysteria2"
	"vpnclient/internal/protocols/naive"
	"vpnclient/internal/protocols/xray"
	"vpnclient/internal/netcheck"
	"vpnclient/internal/remnawave"
	"vpnclient/internal/subscription"
	"vpnclient/internal/sysproxy"
	"vpnclient/internal/vpnmode"
)

// Manager orchestrates protocol engines and Windows system proxy.
type Manager struct {
	mu      sync.Mutex
	cfgPath string
	cfg     *config.Config
	engine  Engine
	sys     sysproxy.Controller
	profile *config.Profile
	stderr  io.Writer
	binDir  string

	// account is the locally remembered Remnawave user (configs/account.json).
	account *remnawave.Account
	// vpn is the active VPN-mode (TUN) session, nil in proxy mode.
	vpn *vpnmode.Session
	// renewMu serializes manual + automatic renewals.
	renewMu sync.Mutex
}

func NewManager(cfgPath string, cfg *config.Config, stderr io.Writer) (*Manager, error) {
	if stderr == nil {
		stderr = os.Stderr
	}
	binDir, err := config.ResolveBinDir(cfgPath, cfg.BinDir)
	if err != nil {
		return nil, err
	}
	acc, err := remnawave.LoadAccount(remnawave.AccountPath(cfgPath))
	if err != nil {
		fmt.Fprintf(stderr, "account.json: %v\n", err)
		acc = nil
	}
	return &Manager{
		cfgPath: cfgPath,
		cfg:     cfg,
		sys:     sysproxy.New(),
		stderr:  stderr,
		binDir:  binDir,
		account: acc,
	}, nil
}

func (m *Manager) Connect(ctx context.Context, profileName string) error {
	m.mu.Lock()
	defer m.mu.Unlock()

	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("already connected; disconnect first")
	}

	if profileName != "" {
		m.cfg.Active = profileName
	}
	profile, err := m.cfg.ActiveProfile()
	if err != nil {
		return err
	}

	engine, err := m.newEngine(profile.Protocol)
	if err != nil {
		return err
	}

	if err := engine.Start(ctx, *profile, m.binDir); err != nil {
		return err
	}

	vpnActive := false
	if m.cfg.Mode == "vpn" {
		if !vpnmode.Supported() {
			_ = engine.Stop()
			return fmt.Errorf("режим VPN пока доступен только на Windows — переключитесь на режим прокси")
		}
		socksAddr, ok := engine.LocalSOCKSProxy()
		if !ok {
			_ = engine.Stop()
			return fmt.Errorf("режим VPN: у протокола нет локального SOCKS-прокси")
		}
		host, _, err := netcheck.HostPort(profile.Protocol, profile.Proxy)
		if err != nil || strings.TrimSpace(host) == "" {
			_ = engine.Stop()
			return fmt.Errorf("режим VPN: не удалось определить адрес сервера для исключения из туннеля")
		}
		sess, err := vpnmode.Start(vpnmode.Config{
			SOCKSAddr:    socksAddr,
			ExcludeHosts: []string{host},
			Stderr:       m.stderr,
		})
		if err != nil {
			_ = engine.Stop()
			return err
		}
		m.vpn = sess
		vpnActive = true
	}

	// System proxy is redundant while the TUN captures everything.
	if m.cfg.SystemProxy && !vpnActive {
		httpProxy, ok := engine.LocalHTTPProxy()
		if !ok {
			_ = engine.Stop()
			return fmt.Errorf("system_proxy requires an http:// listen address in the profile")
		}
		if err := m.sys.Enable(httpProxy); err != nil {
			if errors.Is(err, sysproxy.ErrUnsupported) {
				fmt.Fprintf(m.stderr, "system proxy unsupported on this OS; local SOCKS/HTTP still up\n")
			} else {
				_ = engine.Stop()
				if m.vpn != nil {
					_ = m.vpn.Close()
					m.vpn = nil
				}
				return fmt.Errorf("enable system proxy: %w", err)
			}
		}
	}

	m.engine = engine
	m.profile = profile
	return nil
}

func (m *Manager) Disconnect() error {
	m.mu.Lock()
	sys := m.sys
	engine := m.engine
	vpn := m.vpn
	m.engine = nil
	m.profile = nil
	m.vpn = nil
	m.mu.Unlock()

	var first error
	if vpn != nil {
		if err := vpn.Close(); err != nil && first == nil {
			first = err
		}
	}
	if sys != nil && sys.Enabled() {
		if err := sys.Disable(); err != nil && first == nil {
			first = err
		}
	}
	if engine != nil {
		done := make(chan error, 1)
		go func() { done <- engine.Stop() }()
		select {
		case err := <-done:
			if err != nil && first == nil {
				first = err
			}
		case <-time.After(3 * time.Second):
			// Engine Stop can block on userspace relays; don't freeze the UI.
			if first == nil {
				first = fmt.Errorf("отключение заняло слишком много времени")
			}
		}
	}
	return first
}

func (m *Manager) Status() Status {
	m.mu.Lock()
	defer m.mu.Unlock()

	st := Status{SystemProxy: m.sys.Enabled(), VPNActive: m.vpn != nil}
	if m.engine == nil || !m.engine.Running() {
		return st
	}
	st.Connected = true
	if m.profile != nil {
		st.Profile = m.profile.Name
		st.Protocol = m.profile.Protocol
	}
	if hp, ok := m.engine.LocalHTTPProxy(); ok {
		st.HTTPProxy = hp
	}
	if sp, ok := m.engine.LocalSOCKSProxy(); ok {
		st.SOCKSProxy = sp
	}
	return st
}

// Probe fetches url via the local HTTP or SOCKS proxy to verify the tunnel.
func (m *Manager) Probe(ctx context.Context, testURL string) error {
	m.mu.Lock()
	engine := m.engine
	m.mu.Unlock()
	if engine == nil || !engine.Running() {
		return fmt.Errorf("not connected")
	}
	if testURL == "" {
		testURL = "https://www.google.com/generate_204"
	}

	var proxyURL *url.URL
	if hp, ok := engine.LocalHTTPProxy(); ok {
		proxyURL, _ = url.Parse("http://" + hp)
	} else if sp, ok := engine.LocalSOCKSProxy(); ok {
		proxyURL, _ = url.Parse("socks5://" + sp)
	} else {
		return fmt.Errorf("no local proxy listen address")
	}

	transport := &http.Transport{
		Proxy: http.ProxyURL(proxyURL),
		DialContext: (&net.Dialer{
			Timeout: 15 * time.Second,
		}).DialContext,
		TLSHandshakeTimeout: 15 * time.Second,
		ForceAttemptHTTP2:   true,
	}
	client := &http.Client{
		Transport: transport,
		Timeout:   30 * time.Second,
		CheckRedirect: func(req *http.Request, via []*http.Request) error {
			return http.ErrUseLastResponse
		},
	}
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, testURL, nil)
	if err != nil {
		return err
	}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("probe via %s: %w", proxyURL.String(), err)
	}
	defer resp.Body.Close()
	if resp.StatusCode >= 400 {
		return fmt.Errorf("probe unexpected status %d", resp.StatusCode)
	}
	return nil
}

func (m *Manager) BinDir() string { return m.binDir }

func (m *Manager) ConfigPath() string { return m.cfgPath }

func (m *Manager) Config() *config.Config {
	m.mu.Lock()
	defer m.mu.Unlock()
	return m.cfg
}

func (m *Manager) SetSystemProxy(enabled bool) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.cfg.SystemProxy = enabled
}

// Mode returns the persisted traffic mode: "proxy" (default) or "vpn".
func (m *Manager) Mode() string {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.cfg.Mode == "vpn" {
		return "vpn"
	}
	return "proxy"
}

// SetMode persists the traffic mode; takes effect on next connect.
func (m *Manager) SetMode(mode string) error {
	switch mode {
	case "proxy", "vpn":
	default:
		return fmt.Errorf("неизвестный режим %q", mode)
	}
	if mode == "vpn" {
		if !vpnmode.Supported() {
			return fmt.Errorf("режим VPN пока доступен только на Windows")
		}
		if !vpnmode.IsElevated() {
			return fmt.Errorf("Запустите EvilFox от имени администратора для режима VPN")
		}
		if !vpnmode.WintunAvailable() {
			return fmt.Errorf("не найден wintun.dll — скачайте с wintun.net и положите рядом с EvilFox.exe")
		}
	}
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("сначала отключитесь, затем меняйте режим")
	}
	m.cfg.Mode = mode
	return config.Save(m.cfgPath, *m.cfg)
}

// VPNModeSupported reports whether the VPN (TUN) switch should be shown.
func (m *Manager) VPNModeSupported() bool { return vpnmode.Supported() }

func (m *Manager) UpdateProxyURI(proxy string) error {
	// A plain http(s) URL without credentials is a subscription URL, not a
	// proxy link — run the subscription import instead of failing with
	// "proxy URI missing username".
	if linknorm.LooksLikeSubscriptionURL(proxy) {
		_, err := m.ImportSubscription(proxy)
		return err
	}
	m.mu.Lock()
	defer m.mu.Unlock()
	active, err := m.cfg.ActiveProfile()
	if err != nil {
		return err
	}
	normalized, proto, _, err := linknorm.Normalize(active.Protocol, proxy)
	if err != nil {
		return err
	}
	if err := m.cfg.SetActiveProxy(normalized); err != nil {
		return err
	}
	if proto != "" {
		_ = m.cfg.UpsertProfileWithProtocol(m.cfg.Active, normalized, proto)
	}
	return config.Save(m.cfgPath, *m.cfg)
}

func (m *Manager) SetActiveProfile(name string) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("сначала отключитесь")
	}
	if err := m.cfg.SetActive(name); err != nil {
		return err
	}
	return config.Save(m.cfgPath, *m.cfg)
}

func (m *Manager) SaveProfile(name, proxy string) error {
	// Subscription URL pasted into the "add server link" field → import it.
	if linknorm.LooksLikeSubscriptionURL(proxy) {
		_, err := m.ImportSubscription(proxy)
		return err
	}
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("сначала отключитесь")
	}
	proxy = strings.TrimSpace(proxy)
	var proto config.Protocol
	if proxy != "" {
		normalized, detected, _, err := linknorm.Normalize("", proxy)
		if err != nil {
			return err
		}
		proxy = normalized
		proto = detected
	}
	if err := m.cfg.UpsertProfileWithProtocol(name, proxy, proto); err != nil {
		return err
	}
	if p, err := m.cfg.ActiveProfile(); err == nil {
		hysteria2.EnrichProfile(p)
	}
	return config.Save(m.cfgPath, *m.cfg)
}

// SaveActiveProfile updates the current profile (rename if needed) and proxy URI.
func (m *Manager) SaveActiveProfile(name, proxy string) error {
	// Subscription URL pasted into the profile link field → import it.
	if linknorm.LooksLikeSubscriptionURL(proxy) {
		_, err := m.ImportSubscription(proxy)
		return err
	}
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("сначала отключитесь")
	}
	name = strings.TrimSpace(name)
	if name == "" {
		return fmt.Errorf("имя профиля пустое")
	}
	proxy = strings.TrimSpace(proxy)
	var proto config.Protocol
	if proxy != "" {
		activeProto := config.Protocol("")
		if p, err := m.cfg.ActiveProfile(); err == nil {
			activeProto = p.Protocol
		}
		normalized, detected, _, err := linknorm.Normalize(activeProto, proxy)
		if err != nil {
			return err
		}
		proxy = normalized
		proto = detected
	}

	active := m.cfg.Active
	if name != active {
		exists := false
		for _, p := range m.cfg.Profiles {
			if p.Name == name {
				exists = true
				break
			}
		}
		if exists {
			if err := m.cfg.SetActive(name); err != nil {
				return err
			}
		} else if err := m.cfg.RenameProfile(active, name); err != nil {
			return err
		}
	}
	if err := m.cfg.UpsertProfileWithProtocol(name, proxy, proto); err != nil {
		return err
	}
	if p, err := m.cfg.ActiveProfile(); err == nil {
		hysteria2.EnrichProfile(p)
	}
	return config.Save(m.cfgPath, *m.cfg)
}

func (m *Manager) DeleteProfile(name string) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("сначала отключитесь")
	}
	if err := m.cfg.DeleteProfile(name); err != nil {
		return err
	}
	return config.Save(m.cfgPath, *m.cfg)
}

func (m *Manager) Profiles() []config.ProfileInfo {
	m.mu.Lock()
	defer m.mu.Unlock()
	return m.cfg.ListProfiles()
}

// Hy2Options are editable Hysteria 2 extras for the active profile.
type Hy2Options struct {
	Congestion    string `json:"congestion"`
	BBRProfile    string `json:"bbr_profile"`
	BandwidthUp   string `json:"bandwidth_up"`
	BandwidthDown string `json:"bandwidth_down"`
	Obfs          string `json:"obfs"`
	ObfsPassword  string `json:"obfs_password"`
	SNI           string `json:"sni"`
	Insecure      bool   `json:"insecure"`
	PinSHA256     string `json:"pin_sha256"`
	FastOpen      bool   `json:"fast_open"`
	Lazy          bool   `json:"lazy"`
	HopInterval   string `json:"hop_interval"`
}

func (m *Manager) ActiveHy2Options() Hy2Options {
	m.mu.Lock()
	defer m.mu.Unlock()
	p, err := m.cfg.ActiveProfile()
	if err != nil {
		return Hy2Options{Congestion: "bbr", BBRProfile: "standard"}
	}
	return Hy2Options{
		Congestion:    p.Hy2Congestion,
		BBRProfile:    p.Hy2BBRProfile,
		BandwidthUp:   p.Hy2BandwidthUp,
		BandwidthDown: p.Hy2BandwidthDown,
		Obfs:          p.Hy2Obfs,
		ObfsPassword:  p.Hy2ObfsPassword,
		SNI:           p.Hy2SNI,
		Insecure:      p.Hy2Insecure,
		PinSHA256:     p.Hy2PinSHA256,
		FastOpen:      p.Hy2FastOpen,
		Lazy:          p.Hy2Lazy,
		HopInterval:   p.Hy2HopInterval,
	}
}

func (m *Manager) SaveHy2Options(opts Hy2Options) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("сначала отключитесь")
	}
	p, err := m.cfg.ActiveProfile()
	if err != nil {
		return err
	}
	p.Protocol = config.ProtocolHysteria2
	p.Hy2Congestion = strings.TrimSpace(opts.Congestion)
	p.Hy2BBRProfile = strings.TrimSpace(opts.BBRProfile)
	p.Hy2BandwidthUp = strings.TrimSpace(opts.BandwidthUp)
	p.Hy2BandwidthDown = strings.TrimSpace(opts.BandwidthDown)
	p.Hy2Obfs = strings.TrimSpace(opts.Obfs)
	p.Hy2ObfsPassword = strings.TrimSpace(opts.ObfsPassword)
	p.Hy2SNI = strings.TrimSpace(opts.SNI)
	p.Hy2Insecure = opts.Insecure
	p.Hy2PinSHA256 = strings.TrimSpace(opts.PinSHA256)
	p.Hy2FastOpen = opts.FastOpen
	p.Hy2Lazy = opts.Lazy
	p.Hy2HopInterval = strings.TrimSpace(opts.HopInterval)
	return config.Save(m.cfgPath, *m.cfg)
}

func (m *Manager) SubscriptionURL() string {
	m.mu.Lock()
	defer m.mu.Unlock()
	return m.cfg.SubscriptionURL
}

func (m *Manager) RemnawaveSettings() remnawave.Settings {
	m.mu.Lock()
	defer m.mu.Unlock()
	return remnawave.Settings{
		BaseURL:    m.cfg.RemnawaveBaseURL,
		Token:      m.cfg.RemnawaveToken,
		ShortUUID:  m.cfg.RemnawaveShortUUID,
		CaddyToken: m.cfg.RemnawaveCaddyToken,
	}
}

func (m *Manager) SaveRemnawaveSettings(s remnawave.Settings) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.cfg.RemnawaveBaseURL = remnawave.NormalizeBase(s.BaseURL)
	m.cfg.RemnawaveToken = strings.TrimSpace(s.Token)
	m.cfg.RemnawaveShortUUID = strings.TrimSpace(s.ShortUUID)
	m.cfg.RemnawaveCaddyToken = strings.TrimSpace(s.CaddyToken)
	return config.Save(m.cfgPath, *m.cfg)
}

// ImportResult reports how a subscription import went.
type ImportResult struct {
	Imported int      `json:"imported"`
	Skipped  int      `json:"skipped"`
	Warnings []string `json:"warnings,omitempty"`
}

func (m *Manager) ImportSubscription(rawURL string) (ImportResult, error) {
	rawURL = strings.TrimSpace(rawURL)
	ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
	defer cancel()

	// Remnawave-style URL → persist panel coords and fetch via API helper.
	if base, short, ok := remnawave.ParseInput(rawURL); ok {
		s := remnawave.Settings{
			BaseURL:    base,
			ShortUUID:  short,
			Token:      m.RemnawaveSettings().Token,
			CaddyToken: m.RemnawaveSettings().CaddyToken,
		}
		res, used, err := remnawave.Fetch(ctx, s)
		if err != nil {
			return ImportResult{}, err
		}
		return m.applySubscription(ctx, res, used, &s)
	}

	res, err := subscription.Fetch(ctx, rawURL)
	if err != nil {
		return ImportResult{}, err
	}
	return m.applySubscription(ctx, res, rawURL, nil)
}

// ImportRemnawave fetches configs using saved / provided panel settings.
func (m *Manager) ImportRemnawave(s remnawave.Settings) (ImportResult, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
	defer cancel()
	if strings.TrimSpace(s.BaseURL) == "" || strings.TrimSpace(s.ShortUUID) == "" {
		cur := m.RemnawaveSettings()
		if strings.TrimSpace(s.BaseURL) == "" {
			s.BaseURL = cur.BaseURL
		}
		if strings.TrimSpace(s.ShortUUID) == "" {
			s.ShortUUID = cur.ShortUUID
		}
		if strings.TrimSpace(s.Token) == "" {
			s.Token = cur.Token
		}
		if strings.TrimSpace(s.CaddyToken) == "" {
			s.CaddyToken = cur.CaddyToken
		}
	}
	res, used, err := remnawave.Fetch(ctx, s)
	if err != nil {
		return ImportResult{}, err
	}
	return m.applySubscription(ctx, res, used, &s)
}

func (m *Manager) applySubscription(ctx context.Context, res *subscription.Result, usedURL string, rw *remnawave.Settings) (ImportResult, error) {
	if res == nil || len(res.Items) == 0 {
		if res != nil && res.Skipped > 0 {
			return ImportResult{Skipped: res.Skipped, Warnings: res.Warnings},
				fmt.Errorf("нет валидных серверов: %d записей пропущено (%s)", res.Skipped, strings.Join(res.Warnings, "; "))
		}
		return ImportResult{}, fmt.Errorf("в подписке нет поддерживаемых ссылок (naive / hysteria2 / awg / vless / vmess / trojan)")
	}

	// Subscription usage info: header data first, enriched via Remnawave API
	// (devices / limits) when an API token is configured. Best-effort.
	subInfo := buildSubInfo(res.Info)
	{
		s := m.RemnawaveSettings()
		if rw != nil {
			s = *rw
			if strings.TrimSpace(s.Token) == "" {
				s.Token = m.RemnawaveSettings().Token
			}
		}
		if strings.TrimSpace(s.Token) != "" && strings.TrimSpace(s.BaseURL) != "" && strings.TrimSpace(s.ShortUUID) != "" {
			if ui, err := remnawave.FetchUserInfo(ctx, s); err == nil && ui != nil {
				if subInfo == nil {
					subInfo = &config.SubscriptionInfo{}
				}
				if subInfo.Upload == 0 && subInfo.Download == 0 && ui.UsedTraffic > 0 {
					subInfo.Download = ui.UsedTraffic
				}
				if subInfo.Total == 0 && ui.TrafficLimit > 0 {
					subInfo.Total = ui.TrafficLimit
				}
				if subInfo.Expire == 0 && ui.ExpireAt > 0 {
					subInfo.Expire = ui.ExpireAt
				}
				subInfo.DevicesKnown = ui.DevicesKnown
				subInfo.Devices = ui.Devices
				subInfo.DeviceLimit = ui.DeviceLimit
			}
		}
	}
	if subInfo != nil {
		subInfo.UpdatedAt = time.Now().Unix()
	}

	m.mu.Lock()
	defer m.mu.Unlock()
	if usedURL != "" {
		m.cfg.SubscriptionURL = strings.TrimSpace(usedURL)
	}
	if rw != nil {
		m.cfg.RemnawaveBaseURL = remnawave.NormalizeBase(rw.BaseURL)
		m.cfg.RemnawaveShortUUID = strings.TrimSpace(rw.ShortUUID)
		if t := strings.TrimSpace(rw.Token); t != "" {
			m.cfg.RemnawaveToken = t
		}
		if t := strings.TrimSpace(rw.CaddyToken); t != "" {
			m.cfg.RemnawaveCaddyToken = t
		}
	}
	if subInfo != nil {
		m.cfg.SubInfo = subInfo
	}
	for _, it := range res.Items {
		_ = m.cfg.UpsertProfileWithProtocol(it.Name, it.URI, it.Protocol)
		for i := range m.cfg.Profiles {
			if m.cfg.Profiles[i].Name == it.Name {
				hysteria2.EnrichProfile(&m.cfg.Profiles[i])
				break
			}
		}
	}
	if err := config.Save(m.cfgPath, *m.cfg); err != nil {
		return ImportResult{}, err
	}
	return ImportResult{Imported: len(res.Items), Skipped: res.Skipped, Warnings: res.Warnings}, nil
}

// ProvisionOutcome is what the UI shows after issuing access via the panel.
type ProvisionOutcome struct {
	Username          string `json:"username"`
	Created           bool   `json:"created"`
	SubscriptionURL   string `json:"subscription_url"`
	TrafficLimitBytes int64  `json:"traffic_limit_bytes,omitempty"`
	ExpireAt          int64  `json:"expire_at,omitempty"`
	Imported          int    `json:"imported"`
	Skipped           int    `json:"skipped"`
}

// ProvisionConfigured reports whether the Remnawave admin API is available
// (embedded credentials or configs/remnawave-api.json). Used for renew UI.
func (m *Manager) ProvisionConfigured() bool {
	if remnawave.EmbeddedAdminConfig() != nil {
		return true
	}
	st, err := os.Stat(remnawave.AdminConfigPath(m.cfgPath))
	return err == nil && !st.IsDir()
}

// Account returns a copy of the remembered panel account (nil when absent).
func (m *Manager) Account() *remnawave.Account {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.account == nil {
		return nil
	}
	cp := *m.account
	return &cp
}

func (m *Manager) saveAccount(a *remnawave.Account) {
	m.mu.Lock()
	m.account = a
	m.mu.Unlock()
	if err := remnawave.SaveAccount(remnawave.AccountPath(m.cfgPath), a); err != nil {
		fmt.Fprintf(m.stderr, "account.json: сохранение не удалось: %v\n", err)
	}
}

// ProvisionAccess creates (or finds) a panel user via the Remnawave admin API,
// remembers it locally and imports its subscription configs into the app.
// Once an account is remembered, creating another one is refused —
// paid subscription flow will replace free provisioning later.
func (m *Manager) ProvisionAccess(username string) (ProvisionOutcome, error) {
	if acc := m.Account(); acc != nil {
		return ProvisionOutcome{}, fmt.Errorf("аккаунт уже привязан (%s) — новый создавать нельзя, используйте «Продлить»", acc.Username)
	}
	cfg, err := remnawave.ResolveAdminConfig(m.cfgPath)
	if err != nil {
		return ProvisionOutcome{}, err
	}
	return m.provisionWithConfig(cfg, username)
}

// EnsureAutoProvision silently creates a panel user (if none remembered yet)
// and imports its subscription configs. NordVPN-style: panel address / API
// token are embedded; the user never edits them. Safe to call on every start.
func (m *Manager) EnsureAutoProvision() (ProvisionOutcome, error) {
	if acc := m.Account(); acc != nil {
		// Already provisioned — refresh configs in the background if empty.
		if len(m.Profiles()) == 0 && acc.SubscriptionURL != "" {
			if imp, err := m.ImportSubscription(acc.SubscriptionURL); err == nil {
				return ProvisionOutcome{
					Username:          acc.Username,
					SubscriptionURL:   acc.SubscriptionURL,
					TrafficLimitBytes: acc.TrafficLimitBytes,
					ExpireAt:          acc.ExpireAt,
					Imported:          imp.Imported,
					Skipped:           imp.Skipped,
				}, nil
			}
		}
		return ProvisionOutcome{
			Username:          acc.Username,
			SubscriptionURL:   acc.SubscriptionURL,
			TrafficLimitBytes: acc.TrafficLimitBytes,
			ExpireAt:          acc.ExpireAt,
		}, nil
	}
	cfg, err := remnawave.ResolveAdminConfig(m.cfgPath)
	if err != nil {
		return ProvisionOutcome{}, err
	}
	return m.provisionWithConfig(cfg, remnawave.GenerateUsername())
}

func (m *Manager) provisionWithConfig(cfg *remnawave.AdminConfig, username string) (ProvisionOutcome, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()
	res, err := remnawave.ProvisionUser(ctx, cfg, username)
	if err != nil {
		return ProvisionOutcome{}, err
	}
	out := ProvisionOutcome{
		Username:          res.Username,
		Created:           res.Created,
		SubscriptionURL:   res.SubscriptionURL,
		TrafficLimitBytes: res.TrafficLimitBytes,
		ExpireAt:          res.ExpireAt,
	}
	subURL := res.SubscriptionURL
	if subURL == "" && res.ShortUUID != "" {
		subURL = remnawave.PublicSubURL(cfg.PanelURL, res.ShortUUID)
		out.SubscriptionURL = subURL
	}
	if subURL == "" {
		return out, fmt.Errorf("панель не вернула subscription URL для %s", res.Username)
	}

	// Remember the account — from now on only renewals of this user.
	m.saveAccount(&remnawave.Account{
		Username:          res.Username,
		UUID:              res.UUID,
		ShortUUID:         res.ShortUUID,
		SubscriptionURL:   subURL,
		TrafficLimitBytes: res.TrafficLimitBytes,
		ExpireAt:          res.ExpireAt,
		CreatedAt:         time.Now().Unix(),
	})

	imp, err := m.ImportSubscription(subURL)
	if err != nil {
		return out, fmt.Errorf("доступ выдан (%s), но импорт конфигов не удался: %w", res.Username, err)
	}
	out.Imported = imp.Imported
	out.Skipped = imp.Skipped
	return out, nil
}

// RenewAccount extends the remembered user: resets traffic to the plan
// (50 GB default) and pushes expiry +30 days. Never creates users.
func (m *Manager) RenewAccount() (ProvisionOutcome, error) {
	m.renewMu.Lock()
	defer m.renewMu.Unlock()

	acc := m.Account()
	if acc == nil {
		return ProvisionOutcome{}, fmt.Errorf("нет привязанного аккаунта — сначала выдайте доступ")
	}
	cfg, err := remnawave.ResolveAdminConfig(m.cfgPath)
	if err != nil {
		return ProvisionOutcome{}, err
	}
	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()
	res, err := remnawave.RenewUser(ctx, cfg, acc.UUID, acc.ExpireAt)
	if err != nil {
		return ProvisionOutcome{}, err
	}

	acc.LastRenewedAt = time.Now().Unix()
	if res.ExpireAt > 0 {
		acc.ExpireAt = res.ExpireAt
	}
	if res.TrafficLimitBytes > 0 {
		acc.TrafficLimitBytes = res.TrafficLimitBytes
	}
	if res.SubscriptionURL != "" {
		acc.SubscriptionURL = res.SubscriptionURL
	}
	m.saveAccount(acc)

	out := ProvisionOutcome{
		Username:          acc.Username,
		SubscriptionURL:   acc.SubscriptionURL,
		TrafficLimitBytes: acc.TrafficLimitBytes,
		ExpireAt:          acc.ExpireAt,
	}
	// Refresh configs + usage info; renewal itself already succeeded.
	if acc.SubscriptionURL != "" {
		if imp, err := m.ImportSubscription(acc.SubscriptionURL); err == nil {
			out.Imported = imp.Imported
			out.Skipped = imp.Skipped
		} else {
			fmt.Fprintf(m.stderr, "renew: обновление подписки после продления: %v\n", err)
		}
	}
	fmt.Fprintf(m.stderr, "renew: аккаунт %s продлён до %s\n", acc.Username,
		time.Unix(acc.ExpireAt, 0).Format("2006-01-02"))
	return out, nil
}

// StartAutoRenew launches the monthly auto-renew loop: checks on start and
// then every interval (6h default); renews when expiry is near/past or the
// traffic is exhausted. LastRenewedAt guards against renew loops.
func (m *Manager) StartAutoRenew(interval time.Duration) {
	if interval <= 0 {
		interval = 6 * time.Hour
	}
	go func() {
		time.Sleep(15 * time.Second) // let the app start up first
		for {
			m.maybeAutoRenew()
			time.Sleep(interval)
		}
	}()
}

func (m *Manager) maybeAutoRenew() {
	acc := m.Account()
	if acc == nil || !m.ProvisionConfigured() {
		return
	}
	now := time.Now()
	// Anti-loop: never auto-renew more often than every 12 hours.
	if acc.LastRenewedAt > 0 && now.Sub(time.Unix(acc.LastRenewedAt, 0)) < 12*time.Hour {
		return
	}
	var used int64
	if si := m.SubscriptionInfo(); si != nil {
		used = si.Upload + si.Download
	}
	if !acc.NeedsRenewal(used, now) {
		return
	}
	fmt.Fprintf(m.stderr, "auto-renew: аккаунт %s требует продления (истекает/трафик исчерпан) — продлеваю…\n", acc.Username)
	if _, err := m.RenewAccount(); err != nil {
		fmt.Fprintf(m.stderr, "auto-renew: не удалось: %v\n", err)
	}
}

func buildSubInfo(info *subscription.Info) *config.SubscriptionInfo {
	if info == nil {
		return nil
	}
	return &config.SubscriptionInfo{
		Upload:   info.Upload,
		Download: info.Download,
		Total:    info.Total,
		Expire:   info.Expire,
	}
}

// SubscriptionInfo returns the cached subscription usage info (may be nil).
func (m *Manager) SubscriptionInfo() *config.SubscriptionInfo {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.cfg.SubInfo == nil {
		return nil
	}
	cp := *m.cfg.SubInfo
	return &cp
}

func (m *Manager) SaveConfig() error {
	m.mu.Lock()
	defer m.mu.Unlock()
	return config.Save(m.cfgPath, *m.cfg)
}

func (m *Manager) Reload() error {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("disconnect before reloading config")
	}
	cfg, err := config.Load(m.cfgPath)
	if err != nil {
		return err
	}
	binDir, err := config.ResolveBinDir(m.cfgPath, cfg.BinDir)
	if err != nil {
		return err
	}
	m.cfg = cfg
	m.binDir = binDir
	return nil
}

func (m *Manager) newEngine(p config.Protocol) (Engine, error) {
	switch p {
	case config.ProtocolNaive, "":
		return naive.New(m.stderr), nil
	case config.ProtocolHysteria2:
		return hysteria2.New(m.stderr), nil
	case config.ProtocolAWG:
		return awg.New(m.stderr), nil
	case config.ProtocolVLESS, config.ProtocolVMess, config.ProtocolTrojan:
		return xray.New(m.stderr), nil
	default:
		return nil, fmt.Errorf("unsupported protocol %q", p)
	}
}

// EnsureCore downloads the binary required by the active (or given) protocol.
func (m *Manager) EnsureCore(proto config.Protocol) (string, error) {
	if proto == "" {
		if p, err := m.cfg.ActiveProfile(); err == nil {
			proto = p.Protocol
		}
	}
	switch proto {
	case config.ProtocolHysteria2:
		return hysteria2.EnsureBinary(m.binDir)
	case config.ProtocolAWG:
		return awg.EnsureBinary(m.binDir)
	case config.ProtocolVLESS, config.ProtocolVMess, config.ProtocolTrojan:
		return xray.EnsureBinary(m.binDir)
	default:
		return naive.EnsureBinary(m.binDir)
	}
}

// EnsureAllCores installs naive + hysteria2 + xray cores (AWG is embedded).
func (m *Manager) EnsureAllCores() (map[string]string, error) {
	out := map[string]string{}
	p1, err := naive.EnsureBinary(m.binDir)
	if err != nil {
		return out, fmt.Errorf("naive: %w", err)
	}
	out["naive"] = p1
	p2, err := hysteria2.EnsureBinary(m.binDir)
	if err != nil {
		return out, fmt.Errorf("hysteria2: %w", err)
	}
	out["hysteria2"] = p2
	p3, err := awg.EnsureBinary(m.binDir)
	if err != nil {
		return out, fmt.Errorf("awg: %w", err)
	}
	out["awg"] = p3
	p4, err := xray.EnsureBinary(m.binDir)
	if err != nil {
		return out, fmt.Errorf("xray: %w", err)
	}
	out["xray"] = p4
	return out, nil
}