package state

import (
	"context"
	"path"

	"cuelang.org/go/cue"
	"go.dagger.io/dagger/compiler"
)

// Contents of an environment serialized to a file
type State struct {
	// State path
	Path string `yaml:"-"`

	// Workspace path
	Workspace string `yaml:"-"`

	// Plan
	Plan Plan `yaml:"plan,omitempty"`

	// Human-friendly environment name.
	// A environment may have more than one name.
	// FIXME: store multiple names?
	Name string `yaml:"name,omitempty"`

	// User Inputs
	Inputs map[string]Input `yaml:"inputs,omitempty"`

	// Computed values
	Computed string `yaml:"-"`
}

// Cue module containing the environment plan
func (s *State) CompilePlan(ctx context.Context) (*compiler.Value, error) {
	w := s.Workspace
	// FIXME: backward compatibility
	if mod := s.Plan.Module; mod != "" {
		w = path.Join(w, mod)
	}

	// FIXME: universe vendoring
	// This is already done on `dagger init` and shouldn't be done here too.
	// However:
	// 1) As of right now, there's no way to update universe through the
	// CLI, so we are lazily updating on `dagger up` using the embedded `universe`
	// 2) For backward compatibility: if the workspace was `dagger
	// init`-ed before we added support for vendoring universe, it might not
	// contain a `cue.mod`.
	if err := vendorUniverse(ctx, w); err != nil {
		return nil, err
	}

	args := []string{}
	if pkg := s.Plan.Package; pkg != "" {
		args = append(args, pkg)
	}

	return compiler.Build(w, nil, args...)
}

func (s *State) CompileInputs() (*compiler.Value, error) {
	v := compiler.NewValue()

	// Prepare inputs
	for key, input := range s.Inputs {
		i, err := input.Compile(key, s)
		if err != nil {
			return nil, err
		}
		if key == "" {
			err = v.FillPath(cue.MakePath(), i)
		} else {
			err = v.FillPath(cue.ParsePath(key), i)
		}
		if err != nil {
			return nil, err
		}
	}

	return v, nil
}

// VendorUniverse vendors the latest (built-in) version of the universe into the
// environment's `cue.mod`.
// FIXME: This has nothing to do in `State` and should be tied to a `Workspace`.
// However, since environments could point to different modules before, we have
// to handle vendoring on a per environment basis.
func (s *State) VendorUniverse(ctx context.Context) error {
	w := s.Workspace
	// FIXME: backward compatibility
	if mod := s.Plan.Module; mod != "" {
		w = path.Join(w, mod)
	}

	return vendorUniverse(ctx, w)
}

type Plan struct {
	Module  string `yaml:"module,omitempty"`
	Package string `yaml:"package,omitempty"`
}

func (s *State) SetInput(key string, value Input) error {
	if s.Inputs == nil {
		s.Inputs = make(map[string]Input)
	}
	s.Inputs[key] = value
	return nil
}

// Remove all inputs at the given key, including sub-keys.
// For example RemoveInputs("foo.bar") will remove all inputs
//   at foo.bar, foo.bar.baz, etc.
func (s *State) RemoveInputs(key string) error {
	delete(s.Inputs, key)
	return nil
}