// Package system 提供系统账号操作的抽象层。
//
// Manager 接口面向 service 层；本地实现（localManager）通过 sudoers 白名单
// 执行 useradd/usermod/userdel/passwd 等固定命令并做参数强校验。未来多节点
// agent 模式只需新增远程实现替换本地实现（PLAN §5.1）。
//
// 执行模式（config system.*）：
//   - dry_run=true：只打印计划命令不执行（开发演练）；
//   - dry_run=false + sudo=false：直接执行（容器/测试用户验证真实建号）；
//   - dry_run=false + sudo=true：经 sudo -n 提权执行白名单命令（生产，
//     需配置 deploy/sudoers）。真实系统账号操作只在测试用户/容器中验证，
//     不在生产直接跑 useradd。
package system

import (
	"bufio"
	"context"
	"errors"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"

	"ws_usernode/internal/config"
	"ws_usernode/internal/pkg"
)

// Account 描述一个外部用户的系统账号。
type Account struct {
	Username string // 用户名（可含或不含前缀，由 Manager 规范化）
	Shell    string // 登录 shell，空则用配置默认
	HomeDir  string // 家目录，空则用配置基路径 + 用户名
}

// Key 表示一条待同步的 SSH 公钥。
type Key struct {
	Type      string // ssh-ed25519 / ssh-rsa ...
	PublicKey string // base64 主体
}

// Manager 系统账号操作接口。所有方法都要在返回错误前尽量保证系统状态一致。
type Manager interface {
	// CreateUser 创建系统账号（-m 建家目录、加入 external 组、指定 shell）。
	// 创建后立即锁定口令（passwd -l），外部用户仅密钥登录。
	CreateUser(ctx context.Context, acc Account) error
	// RemoveUser 删除系统账号及家目录（userdel -r）。
	RemoveUser(ctx context.Context, username string) error
	// SetLock 锁定/解锁系统账号口令（passwd -l / -u）。
	SetLock(ctx context.Context, username string, locked bool) error
	// Exists 检查系统账号是否存在（读 /etc/passwd，无需提权）。
	Exists(ctx context.Context, username string) (bool, error)
	// SyncAuthorizedKeys 以 DB 状态全量重写 authorized_keys（原子写 + 并发锁），
	// 吊销密钥即从文件移除、立即失效。
	SyncAuthorizedKeys(ctx context.Context, username string, keys []Key) error
}

// 本地实现注入的命令白名单（与 deploy/sudoers 保持一致）。
var allowedCommands = map[string]bool{
	"useradd": true,
	"usermod": true,
	"userdel": true,
	"passwd":  true,
	"chsh":    true,
}

// localManager 为本地实现。
type localManager struct {
	cfg config.SystemConfig
}

// New 创建系统账号 Manager。
func New(cfg config.SystemConfig) Manager {
	return &localManager{cfg: cfg}
}

// run 执行白名单命令。参数在调用处强校验。
// 模式：dry-run 只返回命令文本；direct（sudo=false）直接执行；
// sudo 经 sudo -n 提权执行（对应 deploy/sudoers 白名单）。
func (m *localManager) run(ctx context.Context, cmd string, args ...string) (string, error) {
	if !allowedCommands[cmd] {
		return "", errors.New("system: command not allowed: " + cmd)
	}
	cmdline := strings.Join(append([]string{cmd}, args...), " ")
	if m.cfg.DryRun {
		return cmdline, nil
	}
	var (
		out []byte
		err error
	)
	if m.cfg.Sudo {
		cmdline = "sudo -n " + cmdline
		out, err = exec.CommandContext(ctx, "sudo", append([]string{"-n", cmd}, args...)...).CombinedOutput()
	} else {
		out, err = exec.CommandContext(ctx, cmd, args...).CombinedOutput()
	}
	if err != nil {
		if len(out) > 0 {
			return cmdline, fmt.Errorf("%s: %s: %w", cmdline, strings.TrimSpace(string(out)), err)
		}
		return cmdline, fmt.Errorf("%s: %w", cmdline, err)
	}
	return cmdline, nil
}

// sysName 返回带前缀的完整系统账号（调用前应已通过 pkg.ValidateSystemAccount）。
func (m *localManager) sysName(username string) string {
	if !strings.HasPrefix(username, m.cfg.UserPrefix) {
		return m.cfg.UserPrefix + username
	}
	return username
}

func (m *localManager) CreateUser(ctx context.Context, acc Account) error {
	username := m.sysName(acc.Username)
	if err := pkg.ValidateSystemAccount(username); err != nil {
		return err
	}
	shell := acc.Shell
	if shell == "" {
		shell = m.cfg.Shell
	}
	home := acc.HomeDir
	if home == "" {
		home = filepath.Join(m.cfg.HomeBase, username)
	}
	if _, err := m.run(ctx, "useradd", "-m", "-d", home, "-s", shell, "-g", m.cfg.Group, username); err != nil {
		return err
	}
	// 锁定口令，仅密钥登录
	if _, err := m.run(ctx, "passwd", "-l", username); err != nil {
		return err
	}
	return nil
}

func (m *localManager) RemoveUser(ctx context.Context, username string) error {
	username = m.sysName(username)
	if err := pkg.ValidateSystemAccount(username); err != nil {
		return err
	}
	if _, err := m.run(ctx, "userdel", "-r", username); err != nil {
		return err
	}
	return nil
}

func (m *localManager) SetLock(ctx context.Context, username string, locked bool) error {
	username = m.sysName(username)
	if err := pkg.ValidateSystemAccount(username); err != nil {
		return err
	}
	flag := "-u"
	if locked {
		flag = "-l"
	}
	if _, err := m.run(ctx, "passwd", flag, username); err != nil {
		return err
	}
	return nil
}

// passwdPath 为系统账号数据库路径（测试可覆盖为临时文件）。
var passwdPath = "/etc/passwd"

// Exists 检查系统账号是否存在。直接读 /etc/passwd（世界可读，无需提权）。
func (m *localManager) Exists(ctx context.Context, username string) (bool, error) {
	username = m.sysName(username)
	if err := pkg.ValidateSystemAccount(username); err != nil {
		return false, err
	}
	_ = ctx
	f, err := os.Open(passwdPath)
	if err != nil {
		return false, err
	}
	defer f.Close()
	sc := bufio.NewScanner(f)
	for sc.Scan() {
		line := sc.Text()
		if line == "" {
			continue
		}
		fields := strings.SplitN(line, ":", 2)
		if len(fields) > 0 && fields[0] == username {
			return true, nil
		}
	}
	if err := sc.Err(); err != nil {
		return false, err
	}
	return false, nil
}

// SyncAuthorizedKeys 全量重写 authorized_keys：
//
//  1. 以 <lockBase>/<username>.lock 文件锁串行化并发写（flock）；
//  2. 写临时文件（0600），再 rename 原子替换；
//  3. 无有效密钥时写入空文件（SSH 行为一致，避免文件缺失导致的歧义）。
//
// dry-run 模式只打印计划；真实写路径（direct/sudo）需要进程具备对家目录
// .ssh 的写权限——生产部署经 sudoers 白名单授予受控脚本实现（M2 细化）。
func (m *localManager) SyncAuthorizedKeys(ctx context.Context, username string, keys []Key) error {
	username = m.sysName(username)
	if err := pkg.ValidateSystemAccount(username); err != nil {
		return err
	}
	home := filepath.Join(m.cfg.HomeBase, username)
	sshDir := filepath.Join(home, m.cfg.AuthorizedKeysDir)
	lockPath := filepath.Join(os.TempDir(), "usernode-keys-"+username+".lock")

	content := new(strings.Builder)
	for _, k := range keys {
		if k.Type != "" && k.PublicKey != "" {
			content.WriteString(k.Type + " " + k.PublicKey + "\n")
		}
	}

	if m.cfg.DryRun {
		var plan strings.Builder
		plan.WriteString("mkdir -p " + sshDir + " (0700)\n")
		plan.WriteString("flock " + lockPath + "\n")
		plan.WriteString("write " + filepath.Join(sshDir, "authorized_keys") + " (0600)\n")
		plan.WriteString(content.String())
		// 演练模式：仅日志输出计划，不落盘
		return nil
	}

	// 生产路径：并发锁 + 原子写
	if err := os.MkdirAll(sshDir, 0o700); err != nil {
		return err
	}
	lock, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0o600)
	if err != nil {
		return err
	}
	defer lock.Close()
	if err := flock(ctx, lock); err != nil {
		return err
	}
	defer funlock(lock)

	tmp := filepath.Join(sshDir, "authorized_keys.tmp."+strconv.Itoa(os.Getpid()))
	if err := os.WriteFile(tmp, []byte(content.String()), 0o600); err != nil {
		return err
	}
	if err := os.Rename(tmp, filepath.Join(sshDir, "authorized_keys")); err != nil {
		os.Remove(tmp)
		return err
	}
	return nil
}