package cli

import (
	"context"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
	"time"

	"github.com/openclaw/gitcrawl/internal/capture"
)

// runCapture exports one deterministic code-free repository snapshot.
func (a *App) runCapture(ctx context.Context, args []string) error {
	fs := flag.NewFlagSet("capture", flag.ContinueOnError)
	fs.SetOutput(io.Discard)
	schema := fs.String("schema", capture.SchemaV1, "capture schema")
	output := fs.String("output", "", "write capture atomically to this path")
	since := fs.String("since", "", "include threads updated at or after this RFC3339 instant")
	jsonOut := fs.Bool("json", false, "write JSON output")
	if err := fs.Parse(normalizeCommandArgs(args, map[string]bool{
		"schema": true,
		"output": true,
		"since":  true,
	})); err != nil {
		return usageErr(err)
	}
	a.applyCommandJSON(*jsonOut)
	if fs.NArg() != 1 {
		return usageErr(fmt.Errorf("capture requires owner/repo"))
	}
	if strings.TrimSpace(*schema) != capture.SchemaV1 {
		return usageErr(fmt.Errorf(
			"unsupported capture schema %q",
			strings.TrimSpace(*schema),
		))
	}
	owner, repoName, err := parseOwnerRepo(fs.Arg(0))
	if err != nil {
		return usageErr(err)
	}
	rt, err := a.openLocalRuntimeReadOnly(ctx)
	if err != nil {
		return err
	}
	defer rt.Store.Close()
	rateLimit, err := a.captureRateLimit(ctx)
	if err != nil {
		return err
	}
	result, err := capture.Build(
		ctx,
		rt.Store,
		owner+"/"+repoName,
		version,
		rateLimit,
		*since,
	)
	if err != nil {
		return err
	}
	data, err := json.MarshalIndent(result, "", "  ")
	if err != nil {
		return fmt.Errorf("encode capture: %w", err)
	}
	data = append(data, '\n')
	if strings.TrimSpace(*output) == "" {
		_, err = a.Stdout.Write(data)
		return err
	}
	return writeCaptureAtomically(*output, data)
}

func (a *App) captureRateLimit(
	ctx context.Context,
) (capture.RateLimit, error) {
	state, ok := a.sharedRateLimitState(ctx)
	if !ok {
		return capture.RateLimit{}, fmt.Errorf(
			"capture rate limit observation is unavailable; run sync with the same GitHub token first",
		)
	}
	var resetAt *string
	if !state.ResetAt.IsZero() {
		formatted := state.ResetAt.UTC().Format(time.RFC3339Nano)
		resetAt = &formatted
	}
	return capture.RateLimit{
		Resource:   state.Resource,
		Limit:      state.Limit,
		Remaining:  state.Remaining,
		ResetAt:    resetAt,
		ObservedAt: state.UpdatedAt.UTC().Format(time.RFC3339Nano),
	}, nil
}

// writeCaptureAtomically publishes a private file without a partial target.
func writeCaptureAtomically(output string, data []byte) error {
	output = filepath.Clean(strings.TrimSpace(output))
	if output == "." || output == "" {
		return fmt.Errorf("capture output path is empty")
	}
	parent := filepath.Dir(output)
	if err := os.MkdirAll(parent, 0o700); err != nil {
		return fmt.Errorf("create capture output directory: %w", err)
	}
	temp, err := os.CreateTemp(parent, "."+filepath.Base(output)+".tmp-*")
	if err != nil {
		return fmt.Errorf("create capture output: %w", err)
	}
	tempPath := temp.Name()
	published := false
	defer func() {
		_ = temp.Close()
		if !published {
			_ = os.Remove(tempPath)
		}
	}()
	if err := temp.Chmod(0o600); err != nil {
		return fmt.Errorf("protect capture output: %w", err)
	}
	if _, err := temp.Write(data); err != nil {
		return fmt.Errorf("write capture output: %w", err)
	}
	if err := temp.Sync(); err != nil {
		return fmt.Errorf("sync capture output: %w", err)
	}
	if err := temp.Close(); err != nil {
		return fmt.Errorf("close capture output: %w", err)
	}
	if err := os.Rename(tempPath, output); err != nil {
		return fmt.Errorf("publish capture output: %w", err)
	}
	published = true
	return nil
}