package cli

import (
	"context"
	"fmt"
	"strconv"
	"time"

	"github.com/google/uuid"
	"golang.org/x/xerrors"

	"github.com/coder/coder/v2/cli/cliui"
	"github.com/coder/coder/v2/codersdk"
	"github.com/coder/pretty"
	"github.com/coder/serpent"
)

// workspaceListRow is the type provided to the OutputFormatter. This is a bit
// dodgy but it's the only way to do complex display code for one format vs. the
// other.
type WorkspaceListRow struct {
	// For JSON format:
	codersdk.Workspace `table:"-"`

	// For table format:
	Favorite         bool      `json:"-" table:"favorite"`
	WorkspaceName    string    `json:"-" table:"workspace,default_sort"`
	OrganizationID   uuid.UUID `json:"-" table:"organization id"`
	OrganizationName string    `json:"-" table:"organization name"`
	Template         string    `json:"-" table:"template"`
	Status           string    `json:"-" table:"status"`
	Healthy          string    `json:"-" table:"healthy"`
	LastBuilt        string    `json:"-" table:"last built"`
	CurrentVersion   string    `json:"-" table:"current version"`
	Outdated         bool      `json:"-" table:"outdated"`
	StartsAt         string    `json:"-" table:"starts at"`
	StartsNext       string    `json:"-" table:"starts next"`
	StopsAfter       string    `json:"-" table:"stops after"`
	StopsNext        string    `json:"-" table:"stops next"`
	DailyCost        string    `json:"-" table:"daily cost"`
}

func WorkspaceListRowFromWorkspace(now time.Time, workspace codersdk.Workspace) WorkspaceListRow {
	status := codersdk.WorkspaceDisplayStatus(workspace.LatestBuild.Job.Status, workspace.LatestBuild.Transition)

	lastBuilt := now.UTC().Sub(workspace.LatestBuild.Job.CreatedAt).Truncate(time.Second)
	schedRow := scheduleListRowFromWorkspace(now, workspace)

	healthy := ""
	if status == "Starting" || status == "Started" {
		healthy = strconv.FormatBool(workspace.Health.Healthy)
	}
	favIco := " "
	if workspace.Favorite {
		favIco = "★"
	}
	workspaceName := favIco + " " + workspace.OwnerName + "/" + workspace.Name
	return WorkspaceListRow{
		Favorite:         workspace.Favorite,
		Workspace:        workspace,
		WorkspaceName:    workspaceName,
		OrganizationID:   workspace.OrganizationID,
		OrganizationName: workspace.OrganizationName,
		Template:         workspace.TemplateName,
		Status:           status,
		Healthy:          healthy,
		LastBuilt:        durationDisplay(lastBuilt),
		CurrentVersion:   workspace.LatestBuild.TemplateVersionName,
		Outdated:         workspace.Outdated,
		StartsAt:         schedRow.StartsAt,
		StartsNext:       schedRow.StartsNext,
		StopsAfter:       schedRow.StopsAfter,
		StopsNext:        schedRow.StopsNext,
		DailyCost:        strconv.Itoa(int(workspace.LatestBuild.DailyCost)),
	}
}

func (r *RootCmd) list() *serpent.Command {
	var (
		filter    cliui.WorkspaceFilter
		formatter = cliui.NewOutputFormatter(
			cliui.TableFormat(
				[]WorkspaceListRow{},
				[]string{
					"workspace",
					"template",
					"status",
					"healthy",
					"last built",
					"current version",
					"outdated",
					"starts at",
					"stops after",
				},
			),
			cliui.JSONFormat(),
		)
		sharedWithMe bool
	)
	cmd := &serpent.Command{
		Annotations: workspaceCommand,
		Use:         "list",
		Short:       "List workspaces",
		Aliases:     []string{"ls"},
		Middleware: serpent.Chain(
			serpent.RequireNArgs(0),
		),
		Options: serpent.OptionSet{
			{
				Name:        "shared-with-me",
				Description: "Show workspaces shared with you.",
				Flag:        "shared-with-me",
				Value:       serpent.BoolOf(&sharedWithMe),
				Hidden:      true,
			},
		},
		Handler: func(inv *serpent.Invocation) error {
			client, err := r.InitClient(inv)
			if err != nil {
				return err
			}

			workspaceFilter := filter.Filter()
			if sharedWithMe {
				user, err := client.User(inv.Context(), codersdk.Me)
				if err != nil {
					return xerrors.Errorf("fetch current user: %w", err)
				}
				workspaceFilter.SharedWithUser = user.ID.String()

				// Unset the default query that conflicts with the --shared-with-me flag
				if workspaceFilter.FilterQuery == "owner:me" {
					workspaceFilter.FilterQuery = ""
				}
			}

			res, err := QueryConvertWorkspaces(inv.Context(), client, workspaceFilter, WorkspaceListRowFromWorkspace)
			if err != nil {
				return err
			}

			out, err := formatter.Format(inv.Context(), res)
			if err != nil {
				return err
			}

			if out == "" {
				pretty.Fprintf(inv.Stderr, cliui.DefaultStyles.Prompt, "No workspaces found! Create one:\n")
				_, _ = fmt.Fprintln(inv.Stderr)
				_, _ = fmt.Fprintln(inv.Stderr, "  "+pretty.Sprint(cliui.DefaultStyles.Code, "coder create <name>"))
				_, _ = fmt.Fprintln(inv.Stderr)
				return nil
			}

			_, err = fmt.Fprintln(inv.Stdout, out)
			return err
		},
	}
	filter.AttachOptions(&cmd.Options)
	formatter.AttachOptions(&cmd.Options)
	return cmd
}

// queryConvertWorkspaces is a helper function for converting
// codersdk.Workspaces to a different type.
// It's used by the list command to convert workspaces to
// WorkspaceListRow, and by the schedule command to
// convert workspaces to scheduleListRow.
func QueryConvertWorkspaces[T any](ctx context.Context, client *codersdk.Client, filter codersdk.WorkspaceFilter, convertF func(time.Time, codersdk.Workspace) T) ([]T, error) {
	var empty []T
	workspaces, err := client.Workspaces(ctx, filter)
	if err != nil {
		return empty, xerrors.Errorf("query workspaces: %w", err)
	}
	converted := make([]T, len(workspaces.Workspaces))
	for i, workspace := range workspaces.Workspaces {
		converted[i] = convertF(time.Now(), workspace)
	}
	return converted, nil
}