package cli

import (
	"bufio"
	"encoding/json"
	"errors"
	"fmt"
	"net/url"
	"reflect"
	"sort"
	"strings"
	"text/tabwriter"

	"github.com/spf13/cobra"
)

type projectAddOptions struct {
	path        string
	id          string
	name        string
	asWorkspace bool
}

type projectListOptions struct {
	json bool
}

type projectGetOptions struct {
	json bool
}

type projectRemoveOptions struct {
	json bool
	yes  bool
}

// addProjectRequest mirrors the daemon's project AddInput body for
// POST /api/v1/projects. projectId and name are optional (pointers omit them).
type addProjectRequest struct {
	Path        string  `json:"path"`
	ProjectID   *string `json:"projectId,omitempty"`
	Name        *string `json:"name,omitempty"`
	AsWorkspace bool    `json:"asWorkspace,omitempty"`
}

type projectSummary struct {
	ID            string `json:"id"`
	Name          string `json:"name"`
	Kind          string `json:"kind"`
	SessionPrefix string `json:"sessionPrefix"`
	ResolveError  string `json:"resolveError,omitempty"`
}

type projectDetails struct {
	ID             string                 `json:"id"`
	Name           string                 `json:"name"`
	Kind           string                 `json:"kind"`
	Path           string                 `json:"path"`
	Repo           string                 `json:"repo"`
	DefaultBranch  string                 `json:"defaultBranch"`
	DefaultHarness string                 `json:"agent,omitempty"`
	Config         *projectConfig         `json:"config,omitempty"`
	WorkspaceRepos []workspaceRepoDetails `json:"workspaceRepos,omitempty"`
	ResolveError   string                 `json:"resolveError,omitempty"`
}

type workspaceRepoDetails struct {
	Name         string `json:"name"`
	RelativePath string `json:"relativePath"`
	Repo         string `json:"repo"`
}

// agentConfig mirrors the daemon's typed domain.AgentConfig for the CLI client.
type agentConfig struct {
	Model       string `json:"model,omitempty"`
	Permissions string `json:"permissions,omitempty"`
}

// roleOverride mirrors domain.RoleOverride.
type roleOverride struct {
	Agent       string      `json:"agent,omitempty"`
	AgentConfig agentConfig `json:"agentConfig,omitempty"`
}

// projectConfig mirrors the daemon's typed domain.ProjectConfig for the CLI
// client. The CLI sets common fields via flags and the whole object via
// --config-json.
type projectConfig struct {
	DefaultBranch string            `json:"defaultBranch,omitempty"`
	SessionPrefix string            `json:"sessionPrefix,omitempty"`
	Env           map[string]string `json:"env,omitempty"`
	Symlinks      []string          `json:"symlinks,omitempty"`
	PostCreate    []string          `json:"postCreate,omitempty"`
	AgentConfig   agentConfig       `json:"agentConfig,omitempty"`
	Worker        roleOverride      `json:"worker,omitempty"`
	Orchestrator  roleOverride      `json:"orchestrator,omitempty"`
}

// setConfigRequest mirrors the daemon's SetConfigInput body for
// PUT /api/v1/projects/{id}/config.
type setConfigRequest struct {
	Config projectConfig `json:"config"`
}

type projectSetConfigOptions struct {
	defaultBranch     string
	sessionPrefix     string
	model             string
	permission        string
	workerAgent       string
	orchestratorAgent string
	env               []string
	symlink           []string
	postCreate        []string
	configJSON        string
	clear             bool
	json              bool
}

type projectListResult struct {
	Projects []projectSummary `json:"projects"`
}

type projectGetResult struct {
	Status  string         `json:"status"`
	Project projectDetails `json:"project"`
}

type projectResult struct {
	Project projectDetails `json:"project"`
}

type projectRemoveResult struct {
	OK                bool   `json:"ok,omitempty"`
	ID                string `json:"id,omitempty"`
	ProjectID         string `json:"projectId,omitempty"`
	RemovedStorageDir *bool  `json:"removedStorageDir,omitempty"`
}

func newProjectCommand(ctx *commandContext) *cobra.Command {
	cmd := &cobra.Command{
		Use:   "project",
		Short: "Manage projects",
	}
	cmd.AddCommand(newProjectListCommand(ctx))
	cmd.AddCommand(newProjectGetCommand(ctx))
	cmd.AddCommand(newProjectAddCommand(ctx))
	cmd.AddCommand(newProjectSetConfigCommand(ctx))
	cmd.AddCommand(newProjectRemoveCommand(ctx))
	return cmd
}

func newProjectListCommand(ctx *commandContext) *cobra.Command {
	var opts projectListOptions
	cmd := &cobra.Command{
		Use:     "ls",
		Aliases: []string{"list"},
		Short:   "List registered projects",
		Args:    noArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			var res projectListResult
			if err := ctx.getJSON(cmd.Context(), "projects", &res); err != nil {
				return err
			}
			sort.Slice(res.Projects, func(i, j int) bool {
				return res.Projects[i].ID < res.Projects[j].ID
			})
			if opts.json {
				return writeJSON(cmd.OutOrStdout(), res)
			}
			return writeProjectList(cmd, res.Projects)
		},
	}
	cmd.Flags().BoolVar(&opts.json, "json", false, "Output projects as JSON")
	return cmd
}

func newProjectGetCommand(ctx *commandContext) *cobra.Command {
	var opts projectGetOptions
	cmd := &cobra.Command{
		Use:   "get <id>",
		Short: "Fetch one registered project",
		Args: func(cmd *cobra.Command, args []string) error {
			if err := cobra.ExactArgs(1)(cmd, args); err != nil {
				return usageError{err}
			}
			if strings.TrimSpace(args[0]) == "" {
				return usageError{errors.New("usage: project id is required")}
			}
			return nil
		},
		RunE: func(cmd *cobra.Command, args []string) error {
			id := strings.TrimSpace(args[0])
			var res projectGetResult
			if err := ctx.getJSON(cmd.Context(), "projects/"+url.PathEscape(id), &res); err != nil {
				return err
			}
			if opts.json {
				return writeJSON(cmd.OutOrStdout(), res)
			}
			return writeProjectDetails(cmd, res)
		},
	}
	cmd.Flags().BoolVar(&opts.json, "json", false, "Output project as JSON")
	return cmd
}

func newProjectAddCommand(ctx *commandContext) *cobra.Command {
	var opts projectAddOptions
	cmd := &cobra.Command{
		Use:   "add",
		Short: "Register a local git repo as a project",
		Long: "Register a local git repo as a project so sessions can be spawned in it.\n\n" +
			"The path must be an existing git repository on disk. With --as-workspace, " +
			"the path may be a parent folder containing direct child git repositories; " +
			"AO initializes/adopts the parent as the root repo and gitignores children.",
		Args: noArgs,
		RunE: func(cmd *cobra.Command, args []string) error {
			if opts.path == "" {
				return usageError{fmt.Errorf("--path is required")}
			}
			req := addProjectRequest{Path: opts.path, AsWorkspace: opts.asWorkspace}
			if opts.id != "" {
				req.ProjectID = &opts.id
			}
			if opts.name != "" {
				req.Name = &opts.name
			}
			var res projectResult
			if err := ctx.postJSON(cmd.Context(), "projects", req, &res); err != nil {
				return err
			}
			_, err := fmt.Fprintf(cmd.OutOrStdout(), "registered project %s at %s\n", res.Project.ID, res.Project.Path)
			return err
		},
	}
	f := cmd.Flags()
	f.StringVar(&opts.path, "path", "", "Absolute path to the local git repo (required)")
	f.StringVar(&opts.id, "id", "", "Project id (default: derived by the daemon from the path)")
	f.StringVar(&opts.name, "name", "", "Display name")
	f.BoolVar(&opts.asWorkspace, "as-workspace", false, "Register a parent folder as a workspace project (root-as-repo plus direct child repos)")
	return cmd
}

func newProjectSetConfigCommand(ctx *commandContext) *cobra.Command {
	var opts projectSetConfigOptions
	cmd := &cobra.Command{
		Use:   "set-config <id>",
		Short: "Set the per-project config",
		Long: "Replace a project's per-project config (branch, session prefix, env, " +
			"symlinks, post-create, agent model/permissions, role overrides). The config " +
			"is resolved when a session spawns.\n\n" +
			"Set fields via flags, pass the whole object with --config-json, or --clear " +
			"to remove all config.",
		Args: func(cmd *cobra.Command, args []string) error {
			if err := cobra.ExactArgs(1)(cmd, args); err != nil {
				return usageError{err}
			}
			if strings.TrimSpace(args[0]) == "" {
				return usageError{errors.New("usage: project id is required")}
			}
			return nil
		},
		RunE: func(cmd *cobra.Command, args []string) error {
			id := strings.TrimSpace(args[0])
			config, err := buildProjectConfig(opts)
			if err != nil {
				return err
			}
			req := setConfigRequest{Config: config}
			var res projectResult
			if err := ctx.putJSON(cmd.Context(), "projects/"+url.PathEscape(id)+"/config", req, &res); err != nil {
				return err
			}
			if opts.json {
				return writeJSON(cmd.OutOrStdout(), res)
			}
			_, err = fmt.Fprintf(cmd.OutOrStdout(), "updated config for project %s\n", res.Project.ID)
			return err
		},
	}
	f := cmd.Flags()
	f.StringVar(&opts.defaultBranch, "default-branch", "", "Base branch new session worktrees are created from")
	f.StringVar(&opts.sessionPrefix, "session-prefix", "", "Displayed session-id prefix")
	f.StringVar(&opts.model, "model", "", "Agent model override (e.g. claude-opus-4-5)")
	f.StringVar(&opts.permission, "permission", "", "Permission mode: default, accept-edits, auto, bypass-permissions")
	f.StringVar(&opts.workerAgent, "worker-agent", "", "Harness override for worker sessions")
	f.StringVar(&opts.orchestratorAgent, "orchestrator-agent", "", "Harness override for orchestrator sessions")
	f.StringArrayVar(&opts.env, "env", nil, "Env var KEY=VALUE forwarded into sessions (repeatable)")
	f.StringArrayVar(&opts.symlink, "symlink", nil, "Repo-relative path to symlink into workspaces (repeatable)")
	f.StringArrayVar(&opts.postCreate, "post-create", nil, "Command to run after workspace creation (repeatable)")
	f.StringVar(&opts.configJSON, "config-json", "", "Full config as a JSON object (overrides field flags)")
	f.BoolVar(&opts.clear, "clear", false, "Clear all config")
	f.BoolVar(&opts.json, "json", false, "Output the updated project as JSON")
	return cmd
}

// buildProjectConfig turns the set-config flags into the typed config sent to
// the daemon. --clear empties the config; --config-json supplies the whole
// object; otherwise the field flags form the config. The daemon validates the
// values.
func buildProjectConfig(opts projectSetConfigOptions) (projectConfig, error) {
	if opts.clear {
		return projectConfig{}, nil
	}
	if opts.configJSON != "" {
		var cfg projectConfig
		if err := json.Unmarshal([]byte(opts.configJSON), &cfg); err != nil {
			return projectConfig{}, usageError{fmt.Errorf("--config-json is not a valid JSON object: %w", err)}
		}
		return cfg, nil
	}

	env, err := parseEnvPairs(opts.env)
	if err != nil {
		return projectConfig{}, err
	}
	cfg := projectConfig{
		DefaultBranch: opts.defaultBranch,
		SessionPrefix: opts.sessionPrefix,
		Env:           env,
		Symlinks:      opts.symlink,
		PostCreate:    opts.postCreate,
		AgentConfig:   agentConfig{Model: opts.model, Permissions: opts.permission},
		Worker:        roleOverride{Agent: opts.workerAgent},
		Orchestrator:  roleOverride{Agent: opts.orchestratorAgent},
	}
	if reflect.DeepEqual(cfg, projectConfig{}) {
		return projectConfig{}, usageError{errors.New("usage: provide at least one config flag, --config-json, or --clear")}
	}
	return cfg, nil
}

// parseEnvPairs turns repeated KEY=VALUE flags into a map.
func parseEnvPairs(pairs []string) (map[string]string, error) {
	if len(pairs) == 0 {
		return nil, nil
	}
	env := make(map[string]string, len(pairs))
	for _, pair := range pairs {
		key, value, ok := strings.Cut(pair, "=")
		key = strings.TrimSpace(key)
		if !ok || key == "" {
			return nil, usageError{fmt.Errorf("invalid --env %q: expected KEY=VALUE", pair)}
		}
		env[key] = value
	}
	return env, nil
}

func newProjectRemoveCommand(ctx *commandContext) *cobra.Command {
	var opts projectRemoveOptions
	cmd := &cobra.Command{
		Use:     "rm <id>",
		Aliases: []string{"remove", "delete"},
		Short:   "Remove a registered project",
		Args: func(cmd *cobra.Command, args []string) error {
			if err := cobra.ExactArgs(1)(cmd, args); err != nil {
				return usageError{err}
			}
			if strings.TrimSpace(args[0]) == "" {
				return usageError{errors.New("usage: project id is required")}
			}
			return nil
		},
		RunE: func(cmd *cobra.Command, args []string) error {
			id := strings.TrimSpace(args[0])
			if !opts.yes {
				confirmed, err := confirmProjectRemoval(cmd, id)
				if err != nil {
					return err
				}
				if !confirmed {
					_, err := fmt.Fprintln(cmd.OutOrStdout(), "aborted")
					return err
				}
			}
			var res projectRemoveResult
			if err := ctx.deleteJSON(cmd.Context(), "projects/"+url.PathEscape(id), &res); err != nil {
				return err
			}
			if opts.json {
				return writeJSON(cmd.OutOrStdout(), res)
			}
			removedID := res.ProjectID
			if removedID == "" {
				removedID = res.ID
			}
			if removedID == "" {
				removedID = id
			}
			_, err := fmt.Fprintf(cmd.OutOrStdout(), "removed project %s\n", removedID)
			return err
		},
	}
	cmd.Flags().BoolVarP(&opts.yes, "yes", "y", false, "Skip confirmation prompt")
	cmd.Flags().BoolVar(&opts.json, "json", false, "Output removal result as JSON")
	return cmd
}

func writeProjectList(cmd *cobra.Command, projects []projectSummary) error {
	out := cmd.OutOrStdout()
	if len(projects) == 0 {
		if _, err := fmt.Fprintln(out, "No projects registered."); err != nil {
			return err
		}
		_, err := fmt.Fprintln(out, "Run `ao project add --path <path>` to register one.")
		return err
	}

	tw := tabwriter.NewWriter(out, 0, 4, 2, ' ', 0)
	if _, err := fmt.Fprintln(tw, "ID\tNAME\tKIND\tSESSION PREFIX\tSTATUS"); err != nil {
		return err
	}
	for _, p := range projects {
		status := "ok"
		if p.ResolveError != "" {
			status = "degraded: " + p.ResolveError
		}
		kind := p.Kind
		if kind == "" {
			kind = "single_repo"
		}
		if _, err := fmt.Fprintf(tw, "%s\t%s\t%s\t%s\t%s\n", p.ID, p.Name, kind, p.SessionPrefix, status); err != nil {
			return err
		}
	}
	return tw.Flush()
}

func writeProjectDetails(cmd *cobra.Command, res projectGetResult) error {
	out := cmd.OutOrStdout()
	p := res.Project
	if _, err := fmt.Fprintf(out, "Project %s (%s)\n", p.ID, res.Status); err != nil {
		return err
	}
	fields := []struct {
		label string
		value string
	}{
		{label: "name", value: p.Name},
		{label: "kind", value: p.Kind},
		{label: "path", value: p.Path},
		{label: "repo", value: p.Repo},
		{label: "default branch", value: p.DefaultBranch},
		{label: "default harness", value: p.DefaultHarness},
		{label: "config", value: formatProjectConfig(p.Config)},
		{label: "resolve error", value: p.ResolveError},
	}
	for _, f := range fields {
		if f.value == "" {
			continue
		}
		if _, err := fmt.Fprintf(out, "  %s: %s\n", f.label, f.value); err != nil {
			return err
		}
	}
	if len(p.WorkspaceRepos) > 0 {
		if _, err := fmt.Fprintln(out, "  workspace repos:"); err != nil {
			return err
		}
		for _, repo := range p.WorkspaceRepos {
			desc := repo.RelativePath
			if repo.Repo != "" {
				desc += " (" + repo.Repo + ")"
			}
			if _, err := fmt.Fprintf(out, "    %s: %s\n", repo.Name, desc); err != nil {
				return err
			}
		}
	}
	return nil
}

// formatProjectConfig renders the per-project config as compact JSON for the
// `project get` text view. A nil config returns "" so the row is skipped.
func formatProjectConfig(config *projectConfig) string {
	if config == nil {
		return ""
	}
	data, err := json.Marshal(config)
	if err != nil {
		return ""
	}
	return string(data)
}

func confirmProjectRemoval(cmd *cobra.Command, id string) (bool, error) {
	if _, err := fmt.Fprintf(cmd.OutOrStdout(), "Remove project %q? Type the project id to confirm: ", id); err != nil {
		return false, err
	}
	reader := bufio.NewReader(cmd.InOrStdin())
	line, err := reader.ReadString('\n')
	if err != nil && line == "" {
		return false, err
	}
	return strings.TrimSpace(line) == id, nil
}