// Copyright IBM Corp. 2014, 2026
// SPDX-License-Identifier: BUSL-1.1

package stackplan

import (
	"context"
	"fmt"

	"github.com/zclconf/go-cty/cty"

	"github.com/hashicorp/terraform/internal/addrs"
	"github.com/hashicorp/terraform/internal/collections"
	"github.com/hashicorp/terraform/internal/configs"
	"github.com/hashicorp/terraform/internal/lang/marks"
	"github.com/hashicorp/terraform/internal/plans"
	"github.com/hashicorp/terraform/internal/providers"
	"github.com/hashicorp/terraform/internal/stacks/stackaddrs"
	"github.com/hashicorp/terraform/internal/states"
	"github.com/hashicorp/terraform/internal/tfdiags"
)

// PlanProducer is an interface of an object that can produce a plan and
// require it to be converted into PlannedChange objects.
type PlanProducer interface {
	Addr() stackaddrs.AbsComponentInstance

	// RequiredComponents returns the static set of components that this
	// component depends on. Static in this context means based on the
	// configuration, so this result shouldn't change based on the type of
	// plan.
	//
	// Normal and destroy plans should return the same set of components,
	// with dependents and dependencies computed from this set during the
	// apply phase.
	RequiredComponents(ctx context.Context) collections.Set[stackaddrs.AbsComponent]

	// ResourceSchema returns the schema for a resource type from a provider.
	ResourceSchema(ctx context.Context, providerTypeAddr addrs.Provider, mode addrs.ResourceMode, resourceType string) (providers.Schema, error)

	// ActionSchema returns the schema for an action type from a provider.
	ActionSchema(ctx context.Context, providerTypeAddr addrs.Provider, actionType string) (providers.ActionSchema, error)
}

func FromPlan(ctx context.Context, config *configs.Config, plan *plans.Plan, refreshPlan *plans.Plan, action plans.Action, producer PlanProducer) ([]PlannedChange, tfdiags.Diagnostics) {
	var diags tfdiags.Diagnostics
	var changes []PlannedChange

	var outputs map[string]cty.Value
	if refreshPlan != nil {
		// we're going to be a little cheeky and publish the outputs as being
		// the results from the refresh part of the plan. This will then be
		// consumed by the apply part of the plan to ensure that the outputs
		// are correctly updated. The refresh plan should only be present if the
		// main plan was a destroy plan in which case the outputs that the
		// apply needs do actually come from the refresh.
		outputs = OutputsFromPlan(config, refreshPlan)
	} else {
		outputs = OutputsFromPlan(config, plan)
	}

	// We must always at least announce that the component instance exists,
	// and that must come before any resource instance changes referring to it.
	changes = append(changes, &PlannedChangeComponentInstance{
		Addr: producer.Addr(),

		Action:                         action,
		Mode:                           plan.UIMode,
		PlanApplyable:                  plan.Applyable,
		PlanComplete:                   plan.Complete,
		RequiredComponents:             producer.RequiredComponents(ctx),
		PlannedInputValues:             plan.VariableValues,
		PlannedInputValueMarks:         plan.VariableMarks,
		PlannedOutputValues:            outputs,
		PlannedCheckResults:            plan.Checks,
		PlannedProviderFunctionResults: plan.FunctionResults,

		// We must remember the plan timestamp so that the plantimestamp
		// function can return a consistent result during a later apply phase.
		PlanTimestamp: plan.Timestamp,
	})

	seenObjects := addrs.MakeSet[addrs.AbsResourceInstanceObject]()
	for _, rsrcChange := range plan.Changes.Resources {
		schema, err := producer.ResourceSchema(
			ctx,
			rsrcChange.ProviderAddr.Provider,
			rsrcChange.Addr.Resource.Resource.Mode,
			rsrcChange.Addr.Resource.Resource.Type,
		)
		if err != nil {
			diags = diags.Append(tfdiags.Sourceless(
				tfdiags.Error,
				"Can't fetch provider schema to save plan",
				fmt.Sprintf(
					"Failed to retrieve the schema for %s from provider %s: %s. This is a bug in Terraform.",
					rsrcChange.Addr, rsrcChange.ProviderAddr.Provider, err,
				),
			))
			continue
		}

		objAddr := addrs.AbsResourceInstanceObject{
			ResourceInstance: rsrcChange.Addr,
			DeposedKey:       rsrcChange.DeposedKey,
		}
		var priorStateSrc *states.ResourceInstanceObjectSrc
		if plan.PriorState != nil {
			priorStateSrc = plan.PriorState.ResourceInstanceObjectSrc(objAddr)
		}

		changes = append(changes, &PlannedChangeResourceInstancePlanned{
			ResourceInstanceObjectAddr: stackaddrs.AbsResourceInstanceObject{
				Component: producer.Addr(),
				Item:      objAddr,
			},
			ChangeSrc:          rsrcChange,
			Schema:             schema,
			PriorStateSrc:      priorStateSrc,
			ProviderConfigAddr: rsrcChange.ProviderAddr,

			// TODO: Also provide the previous run state, if it's
			// different from the prior state, and signal whether the
			// difference from previous run seems "notable" per
			// Terraform Core's heuristics. Only the external plan
			// description needs that info, to populate the
			// "changes outside of Terraform" part of the plan UI;
			// the raw plan only needs the prior state.
		})
		seenObjects.Add(objAddr)
	}

	// We need to keep track of the deferred changes as well
	for _, dr := range plan.DeferredResources {
		rsrcChange := dr.ChangeSrc
		objAddr := addrs.AbsResourceInstanceObject{
			ResourceInstance: rsrcChange.Addr,
			DeposedKey:       rsrcChange.DeposedKey,
		}
		var priorStateSrc *states.ResourceInstanceObjectSrc
		if plan.PriorState != nil {
			priorStateSrc = plan.PriorState.ResourceInstanceObjectSrc(objAddr)
		}

		schema, err := producer.ResourceSchema(
			ctx,
			rsrcChange.ProviderAddr.Provider,
			rsrcChange.Addr.Resource.Resource.Mode,
			rsrcChange.Addr.Resource.Resource.Type,
		)
		if err != nil {
			diags = diags.Append(tfdiags.Sourceless(
				tfdiags.Error,
				"Can't fetch provider schema to save plan",
				fmt.Sprintf(
					"Failed to retrieve the schema for %s from provider %s: %s. This is a bug in Terraform.",
					rsrcChange.Addr, rsrcChange.ProviderAddr.Provider, err,
				),
			))
			continue
		}

		plannedChangeResourceInstance := PlannedChangeResourceInstancePlanned{
			ResourceInstanceObjectAddr: stackaddrs.AbsResourceInstanceObject{
				Component: producer.Addr(),
				Item:      objAddr,
			},
			ChangeSrc:          rsrcChange,
			Schema:             schema,
			PriorStateSrc:      priorStateSrc,
			ProviderConfigAddr: rsrcChange.ProviderAddr,
		}
		changes = append(changes, &PlannedChangeDeferredResourceInstancePlanned{
			DeferredReason:          dr.DeferredReason,
			ResourceInstancePlanned: plannedChangeResourceInstance,
		})
		seenObjects.Add(objAddr)
	}

	// Handle action invocations from the plan
	for _, actionChange := range plan.Changes.ActionInvocations {
		schema, err := producer.ActionSchema(
			ctx,
			actionChange.ProviderAddr.Provider,
			actionChange.Addr.Action.Action.Type,
		)
		if err != nil {
			diags = diags.Append(tfdiags.Sourceless(
				tfdiags.Error,
				"Can't fetch provider schema to save plan",
				fmt.Sprintf(
					"Failed to retrieve the schema for %s from provider %s: %s. This is a bug in Terraform.",
					actionChange.Addr, actionChange.ProviderAddr.Provider, err,
				),
			))
			continue
		}

		changes = append(changes, &PlannedChangeActionInvocationInstancePlanned{
			ActionInvocationAddr: stackaddrs.AbsActionInvocationInstance{
				Component: producer.Addr(),
				Item:      actionChange.Addr,
			},
			Invocation:         actionChange,
			Schema:             schema,
			ProviderConfigAddr: actionChange.ProviderAddr,
		})
	}

	// Handle deferred action invocations from the plan
	for _, deferredAction := range plan.DeferredActionInvocations {
		invocation := deferredAction.ActionInvocationInstanceSrc

		if invocation == nil {
			continue
		}

		// For deferred actions, the provider address is typically empty because
		// actions are deferred before being fully evaluated. We create the planned
		// change without schema since we can't fetch it without a provider address.
		plannedActionInvocation := PlannedChangeActionInvocationInstancePlanned{
			ActionInvocationAddr: stackaddrs.AbsActionInvocationInstance{
				Component: producer.Addr(),
				Item:      invocation.Addr,
			},
			Invocation:         invocation,
			Schema:             providers.ActionSchema{}, // Empty schema for deferred actions
			ProviderConfigAddr: invocation.ProviderAddr,  // Will be empty, that's expected
		}
		changes = append(changes, &PlannedChangeDeferredActionInvocation{
			DeferredReason:          deferredAction.DeferredReason,
			ActionInvocationPlanned: plannedActionInvocation,
		})
	}

	// We also need to catch any objects that exist in the "prior state"
	// but don't have any actions planned, since we still need to capture
	// the prior state part in case it was updated by refreshing during
	// the plan walk.
	if priorState := plan.PriorState; priorState != nil {
		for _, addr := range priorState.AllResourceInstanceObjectAddrs() {
			if seenObjects.Has(addr) {
				// We're only interested in objects that didn't appear
				// in the plan, such as data resources whose read has
				// completed during the plan phase.
				continue
			}

			rs := priorState.Resource(addr.ResourceInstance.ContainingResource())
			os := priorState.ResourceInstanceObjectSrc(addr)
			schema, err := producer.ResourceSchema(
				ctx,
				rs.ProviderConfig.Provider,
				addr.ResourceInstance.Resource.Resource.Mode,
				addr.ResourceInstance.Resource.Resource.Type,
			)
			if err != nil {
				diags = diags.Append(tfdiags.Sourceless(
					tfdiags.Error,
					"Can't fetch provider schema to save plan",
					fmt.Sprintf(
						"Failed to retrieve the schema for %s from provider %s: %s. This is a bug in Terraform.",
						addr, rs.ProviderConfig.Provider, err,
					),
				))
				continue
			}

			changes = append(changes, &PlannedChangeResourceInstancePlanned{
				ResourceInstanceObjectAddr: stackaddrs.AbsResourceInstanceObject{
					Component: producer.Addr(),
					Item:      addr,
				},
				Schema:             schema,
				PriorStateSrc:      os,
				ProviderConfigAddr: rs.ProviderConfig,
				// We intentionally omit ChangeSrc, because we're not actually
				// planning to change this object during the apply phase, only
				// to update its state data.
			})
			seenObjects.Add(addr)
		}
	}

	prevRunState := plan.PrevRunState
	if refreshPlan != nil {
		// If we executed a refresh plan as part of this, then the true
		// previous run state is the one from the refresh plan, because
		// the later plan used the output of the refresh plan as the
		// previous state.
		prevRunState = refreshPlan.PrevRunState
	}

	// We also have one more unusual case to deal with: if an object
	// existed at the end of the previous run but was found to have
	// been deleted when we refreshed during planning then it will
	// not be present in either the prior state _or_ the plan, but
	// we still need to include a stubby object for it in the plan
	// so we can remember to discard it from the state during the
	// apply phase.
	if prevRunState != nil {
		for _, addr := range prevRunState.AllResourceInstanceObjectAddrs() {
			if seenObjects.Has(addr) {
				// We're only interested in objects that didn't appear
				// in the plan, such as data resources whose read has
				// completed during the plan phase.
				continue
			}

			rs := prevRunState.Resource(addr.ResourceInstance.ContainingResource())

			changes = append(changes, &PlannedChangeResourceInstancePlanned{
				ResourceInstanceObjectAddr: stackaddrs.AbsResourceInstanceObject{
					Component: producer.Addr(),
					Item:      addr,
				},
				ProviderConfigAddr: rs.ProviderConfig,
				// Everything except the addresses are omitted in this case,
				// which represents that we should just delete the object
				// from the state when applied, and not take any other
				// action.
			})
			seenObjects.Add(addr)
		}
	}

	return changes, diags
}

func OutputsFromPlan(config *configs.Config, plan *plans.Plan) map[string]cty.Value {
	if plan == nil {
		return nil
	}

	// We need to vary our behavior here slightly depending on what action
	// we're planning to take with this overall component: normally we want
	// to use the "planned new state"'s output values, but if we're actually
	// planning to destroy all of the infrastructure managed by this
	// component then the planned new state has no output values at all,
	// so we'll use the prior state's output values instead just in case
	// we also need to plan destroying another component instance
	// downstream of this one which will make use of this instance's
	// output values _before_ we destroy it.
	//
	// FIXME: We're using UIMode for this decision, despite its doc comment
	// saying we shouldn't, because this behavior is an offshoot of the
	// already-documented annoying exception to that rule where various
	// parts of Terraform use UIMode == DestroyMode in particular to deal
	// with necessary variations during a "full destroy". Hopefully we'll
	// eventually find a more satisfying solution for that, in which case
	// we should update the following to use that solution too.
	attrs := make(map[string]cty.Value)
	switch plan.UIMode {
	case plans.DestroyMode:
		// The "prior state" of the plan includes any new information we
		// learned by "refreshing" before we planned to destroy anything,
		// and so should be as close as possible to the current
		// (pre-destroy) state of whatever infrastructure this component
		// instance is managing.
		for _, os := range plan.PriorState.RootOutputValues {
			v := os.Value
			if os.Sensitive {
				// For our purposes here, a static sensitive flag on the
				// output value is indistinguishable from the value having
				// been dynamically marked as sensitive.
				v = v.Mark(marks.Sensitive)
			}
			attrs[os.Addr.OutputValue.Name] = v
		}
	default:
		for _, changeSrc := range plan.Changes.Outputs {
			if len(changeSrc.Addr.Module) > 0 {
				// Only include output values of the root module as part
				// of the component.
				continue
			}

			name := changeSrc.Addr.OutputValue.Name
			change, err := changeSrc.Decode()
			if err != nil {
				attrs[name] = cty.DynamicVal
				continue
			}

			if changeSrc.Sensitive {
				// For our purposes here, a static sensitive flag on the
				// output value is indistinguishable from the value having
				// been dynamically marked as sensitive.
				attrs[name] = change.After.Mark(marks.Sensitive)
				continue
			}

			// Otherwise, just use the value as-is.
			attrs[name] = change.After
		}
	}

	if config != nil {
		// If the plan only ran partially then we might be missing
		// some planned changes for output values, which could
		// cause "attrs" to have an incomplete set of attributes.
		// To avoid confusing downstream errors we'll insert unknown
		// values for any declared output values that don't yet
		// have a final value.
		for name := range config.Module.Outputs {
			if _, ok := attrs[name]; !ok {
				// We can't do any better than DynamicVal because
				// output values in the modules language don't
				// have static type constraints.
				attrs[name] = cty.DynamicVal
			}
		}
		// In the DestroyMode case above we might also find ourselves
		// with some remnant additional output values that have since
		// been removed from the configuration, but yet remain in the
		// state. Destroying with a different configuration than was
		// most recently applied is not guaranteed to work, but we
		// can make it more likely to work by dropping anything that
		// isn't currently declared, since referring directly to these
		// would be a static validation error anyway, and including
		// them might cause aggregate operations like keys(component.foo)
		// to produce broken results.
		for name := range attrs {
			_, declared := config.Module.Outputs[name]
			if !declared {
				// (deleting map elements during iteration is valid in Go,
				// unlike some other languages.)
				delete(attrs, name)
			}
		}
	}

	return attrs
}
