// 2026-03-07
// function_resource.go — Terraform ресурс sless_function.
//
// Lifecycle:
//
//	Create:     POST /functions → если code_path задан: upload zip → WaitReady (5 мин)
//	Read:       GET /functions/{name} → sync state
//	Update:     PUT /functions/{name} → если code_hash изменился: upload zip → WaitReady
//	Delete:     DELETE /functions/{name}
//	ModifyPlan: вычисляет hash source_dir на фазе plan → terraform видит diff при изменении кода
//
// code_hash — пользователь задаёт сам (например filemd5("./handler.zip")).
// Изменение hash → провайдер перезагружает zip и ждёт новой сборки.
// Это стандартный паттерн для file-based ресурсов в terraform-plugin-framework.
//
// При переносе в nubes: файл кладётся в internal/resources_gen/ без изменений,
// client.Client заменяется на *core.UniversalClient или аналогичный.
package resources

import (
	"archive/zip"
	"bytes"
	"context"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"sort"
	"time"

	"terraform-provider-sless/internal/client"

	"github.com/hashicorp/terraform-plugin-framework-validators/int64validator"
	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
	"github.com/hashicorp/terraform-plugin-framework/diag"
	"github.com/hashicorp/terraform-plugin-framework/resource"
	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
	"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
	"github.com/hashicorp/terraform-plugin-framework/types"
)

// defaultBuildTimeoutSec — дефолтный таймаут ожидания kaniko-сборки (300 сек = 5 мин).
// Пользователь может переопределить через build_timeout_sec.
const defaultBuildTimeoutSec = 300

var _ resource.Resource = &FunctionResource{}
var _ resource.ResourceWithModifyPlan = &FunctionResource{}

type FunctionResource struct {
	client *client.Client
}

func NewFunctionResource() resource.Resource {
	return &FunctionResource{}
}

// FunctionModel — модель состояния terraform для sless_function.
type FunctionModel struct {
	Name       types.String `tfsdk:"name"`
	Runtime    types.String `tfsdk:"runtime"`
	Entrypoint types.String `tfsdk:"entrypoint"`
	MemoryMB   types.Int64  `tfsdk:"memory_mb"`
	TimeoutSec types.Int64  `tfsdk:"timeout_sec"`
	EnvVars    types.Map    `tfsdk:"env_vars"`
	CodePath   types.String `tfsdk:"code_path"`
	// source_dir — директория с исходниками. Провайдер сам упакует в zip и загрузит.
	// Взаимоисключающе с code_path. Не требует hashicorp/archive.
	SourceDir types.String `tfsdk:"source_dir"`
	// code_hash — sha256 содержимого. При code_path: задаётся вручную.
	// При source_dir: провайдер вычисляет сам и хранит в state для детекции изменений.
	CodeHash types.String `tfsdk:"code_hash"`
	// build_timeout_sec — максимальное ожидание kaniko-сборки. Дефолт 300 сек.
	BuildTimeoutSec types.Int64  `tfsdk:"build_timeout_sec"`
	Phase           types.String `tfsdk:"phase"`
	ImageRef        types.String `tfsdk:"image_ref"`
}

func (r *FunctionResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
	resp.TypeName = req.ProviderTypeName + "_function"
}

func (r *FunctionResource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
	resp.Schema = schema.Schema{
		Attributes: map[string]schema.Attribute{
			// name — immutable, смена требует пересоздания ресурса
			"name": schema.StringAttribute{
				Required: true,
				PlanModifiers: []planmodifier.String{
					stringplanmodifier.RequiresReplace(),
				},
			},
			"runtime": schema.StringAttribute{
				Required: true,
				PlanModifiers: []planmodifier.String{
					stringplanmodifier.RequiresReplace(),
				},
				Validators: []validator.String{
					stringvalidator.OneOf("nodejs20", "python3.11", "go1.23"),
				},
			},
			"entrypoint": schema.StringAttribute{
				Optional: true,
				Computed: true,
				PlanModifiers: []planmodifier.String{
					stringplanmodifier.UseStateForUnknown(),
				},
			},
			"memory_mb": schema.Int64Attribute{
				Optional: true,
				Computed: true,
				Validators: []validator.Int64{
					int64validator.Between(1, 4096),
				},
			},
			"timeout_sec": schema.Int64Attribute{
				Optional: true,
				Computed: true,
				Validators: []validator.Int64{
					int64validator.Between(1, 900),
				},
			},
			"env_vars": schema.MapAttribute{
				ElementType: types.StringType,
				Optional:    true,
			},
			"code_path": schema.StringAttribute{
				Optional: true,
			},
			// source_dir — путь к директории с исходниками. Провайдер сам соберёт zip без archive provider.
			"source_dir": schema.StringAttribute{
				Optional:            true,
				MarkdownDescription: "Путь к директории с исходным кодом. Провайдер сам упакует в zip. Не нужен archive provider.",
			},
			// code_hash — при code_path: задаётся вручную; при source_dir: вычисляется автоматически.
			"code_hash": schema.StringAttribute{
				Optional: true,
				Computed: true,
			},
			// build_timeout_sec — таймаут ожидания kaniko-сборки. Дефолт 300 сек (5 мин).
			// Увеличь если функция с тяжёлыми зависимостями (например torch).
			"build_timeout_sec": schema.Int64Attribute{
				Optional:            true,
				Computed:            true,
				MarkdownDescription: "Таймаут ожидания сборки образа в секундах. По умолчанию 300 (5 мин).",
			},
			// phase, image_ref — только для чтения, вычисляются оператором
			"phase": schema.StringAttribute{
				Computed: true,
				PlanModifiers: []planmodifier.String{
					stringplanmodifier.UseStateForUnknown(),
				},
			},
			// image_ref — только для чтения, вычисляется оператором после сборки образа.
			// Намеренно без UseStateForUnknown: при пересборке (смена code_hash) image_ref
			// может измениться (например смена registry), поэтому всегда (known after apply).
			"image_ref": schema.StringAttribute{
				Computed: true,
			},
		},
	}
}

func (r *FunctionResource) Configure(_ context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse) {
	if req.ProviderData == nil {
		return
	}
	c, ok := req.ProviderData.(*client.Client)
	if !ok {
		resp.Diagnostics.AddError(
			"unexpected provider data",
			fmt.Sprintf("expected *client.Client, got: %T", req.ProviderData),
		)
		return
	}
	r.client = c
}

func (r *FunctionResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
	var plan FunctionModel
	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
	if resp.Diagnostics.HasError() {
		return
	}

	ns := r.client.Namespace
	envVars, d := mapToStringMap(ctx, plan.EnvVars)
	resp.Diagnostics.Append(d...)
	if resp.Diagnostics.HasError() {
		return
	}

	fn, err := r.client.CreateFunction(ctx, ns, client.FunctionRequest{
		Name:       plan.Name.ValueString(),
		Runtime:    plan.Runtime.ValueString(),
		Entrypoint: plan.Entrypoint.ValueString(),
		MemoryMB:   int32(plan.MemoryMB.ValueInt64()),
		TimeoutSec: int32(plan.TimeoutSec.ValueInt64()),
		Env:        envVars,
	})
	if err != nil {
		resp.Diagnostics.AddError("create function", err.Error())
		return
	}

	var codeUploaded bool
	if !plan.SourceDir.IsNull() && plan.SourceDir.ValueString() != "" {
		// source_dir: провайдер сам собирает zip и вычисляет hash
		zipData, hash, err := zipDir(plan.SourceDir.ValueString())
		if err != nil {
			resp.Diagnostics.AddError("zip source_dir", err.Error())
			return
		}
		if err := r.client.UploadCodeReader(ctx, ns, fn.Name, "code.zip", bytes.NewReader(zipData)); err != nil {
			resp.Diagnostics.AddError("upload code", err.Error())
			return
		}
		plan.CodeHash = types.StringValue(hash)
		codeUploaded = true
	} else if !plan.CodePath.IsNull() && plan.CodePath.ValueString() != "" {
		// code_path: старый путь, для обратной совместимости
		if err := r.client.UploadCode(ctx, ns, fn.Name, plan.CodePath.ValueString()); err != nil {
			resp.Diagnostics.AddError("upload code", err.Error())
			return
		}
		codeUploaded = true
	}
	if codeUploaded {
		buildSec := plan.BuildTimeoutSec.ValueInt64()
		if buildSec <= 0 {
			buildSec = defaultBuildTimeoutSec
		}
		fn, err = r.client.WaitReady(ctx, ns, fn.Name, time.Duration(buildSec)*time.Second)
		if err != nil {
			resp.Diagnostics.AddError("waiting for function ready", err.Error())
			return
		}
	}

	resp.Diagnostics.Append(resp.State.Set(ctx, fnToModel(plan, fn))...)
}

func (r *FunctionResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) {
	var state FunctionModel
	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
	if resp.Diagnostics.HasError() {
		return
	}

	fn, err := r.client.GetFunction(ctx, r.client.Namespace, state.Name.ValueString())
	if err != nil {
		resp.Diagnostics.AddError("read function", err.Error())
		return
	}
	if fn == nil {
		// Ресурс удалён вне terraform — убираем из state
		resp.State.RemoveResource(ctx)
		return
	}

	resp.Diagnostics.Append(resp.State.Set(ctx, fnToModel(state, fn))...)
}

func (r *FunctionResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) {
	var plan, state FunctionModel
	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
	if resp.Diagnostics.HasError() {
		return
	}

	ns := r.client.Namespace
	name := plan.Name.ValueString()

	envVars, d := mapToStringMap(ctx, plan.EnvVars)
	resp.Diagnostics.Append(d...)
	if resp.Diagnostics.HasError() {
		return
	}

	fn, err := r.client.UpdateFunction(ctx, ns, name, client.FunctionRequest{
		Name:       name,
		Runtime:    plan.Runtime.ValueString(),
		Entrypoint: plan.Entrypoint.ValueString(),
		MemoryMB:   int32(plan.MemoryMB.ValueInt64()),
		TimeoutSec: int32(plan.TimeoutSec.ValueInt64()),
		Env:        envVars,
	})
	if err != nil {
		resp.Diagnostics.AddError("update function", err.Error())
		return
	}

	var codeUploaded bool
	if !plan.SourceDir.IsNull() && plan.SourceDir.ValueString() != "" {
		// source_dir: пересчитываем hash и загружаем только если изменился
		zipData, hash, err := zipDir(plan.SourceDir.ValueString())
		if err != nil {
			resp.Diagnostics.AddError("zip source_dir", err.Error())
			return
		}
		newHash := types.StringValue(hash)
		if !newHash.Equal(state.CodeHash) {
			if err := r.client.UploadCodeReader(ctx, ns, name, "code.zip", bytes.NewReader(zipData)); err != nil {
				resp.Diagnostics.AddError("upload code", err.Error())
				return
			}
			codeUploaded = true
		}
		plan.CodeHash = newHash
	} else if !plan.CodeHash.Equal(state.CodeHash) && !plan.CodePath.IsNull() && plan.CodePath.ValueString() != "" {
		// code_path: загружаем только если code_hash изменился вручную
		if err := r.client.UploadCode(ctx, ns, name, plan.CodePath.ValueString()); err != nil {
			resp.Diagnostics.AddError("upload code", err.Error())
			return
		}
		codeUploaded = true
	}
	if codeUploaded {
		buildSec := plan.BuildTimeoutSec.ValueInt64()
		if buildSec <= 0 {
			buildSec = defaultBuildTimeoutSec
		}
		fn, err = r.client.WaitReady(ctx, ns, name, time.Duration(buildSec)*time.Second)
		if err != nil {
			resp.Diagnostics.AddError("waiting for function ready", err.Error())
			return
		}
	}

	resp.Diagnostics.Append(resp.State.Set(ctx, fnToModel(plan, fn))...)
}

func (r *FunctionResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) {
	var state FunctionModel
	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
	if resp.Diagnostics.HasError() {
		return
	}

	if err := r.client.DeleteFunction(ctx, r.client.Namespace, state.Name.ValueString()); err != nil {
		resp.Diagnostics.AddError("delete function", err.Error())
	}
}

// ModifyPlan вычисляет hash директории source_dir на фазе terraform plan.
// Без этого terraform не видит изменения файлов кода между apply — потому что
// code_hash Computed и при plan берётся из state. Здесь мы явно пересчитываем
// и записываем актуальный hash в plan → если отличается от state, terraform
// показывает diff и вызывает Update.
func (r *FunctionResource) ModifyPlan(ctx context.Context, req resource.ModifyPlanRequest, resp *resource.ModifyPlanResponse) {
	// При destroy plan пустой — ничего не делаем
	if req.Plan.Raw.IsNull() {
		return
	}
	var plan FunctionModel
	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
	if resp.Diagnostics.HasError() {
		return
	}
	// source_dir не задан — нечего считать
	if plan.SourceDir.IsNull() || plan.SourceDir.ValueString() == "" {
		return
	}
	_, hash, err := zipDir(plan.SourceDir.ValueString())
	if err != nil {
		// Директория может не существовать при первом init — не фейлим plan
		return
	}
	plan.CodeHash = types.StringValue(hash)
	resp.Diagnostics.Append(resp.Plan.Set(ctx, plan)...)
}

// fnToModel конвертирует API-ответ + plan (для локальных полей) → state модель.
// plan используется для code_path, code_hash, build_timeout_sec — API их не хранит.
func fnToModel(plan FunctionModel, fn *client.FunctionResponse) FunctionModel {
	buildTimeoutSec := plan.BuildTimeoutSec
	// Если не задан пользователем — записываем дефолт чтобы не было null в state
	if buildTimeoutSec.IsNull() || buildTimeoutSec.IsUnknown() || buildTimeoutSec.ValueInt64() <= 0 {
		buildTimeoutSec = types.Int64Value(defaultBuildTimeoutSec)
	}
	return FunctionModel{
		Name:            types.StringValue(fn.Name),
		Runtime:         types.StringValue(fn.Runtime),
		Entrypoint:      types.StringValue(fn.Entrypoint),
		MemoryMB:        types.Int64Value(int64(fn.MemoryMB)),
		TimeoutSec:      types.Int64Value(int64(fn.TimeoutSec)),
		EnvVars:         plan.EnvVars, // API возвращает null для пустого map — берём из plan
		CodePath:        plan.CodePath,
		SourceDir:       plan.SourceDir,
		CodeHash:        plan.CodeHash,
		BuildTimeoutSec: buildTimeoutSec,
		Phase:           types.StringValue(fn.Phase),
		ImageRef:        types.StringValue(fn.ImageRef),
	}
}

// zipDir упаковывает директорию dir в zip-архив (in-memory) и возвращает байты + SHA256 содержимого.
// Сортирует файлы по пути для детерминированного хеша — одинаковый код даёт одинаковый hash.
func zipDir(dir string) ([]byte, string, error) {
	var paths []string
	err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if !d.IsDir() {
			paths = append(paths, path)
		}
		return nil
	})
	if err != nil {
		return nil, "", fmt.Errorf("walk dir %q: %w", dir, err)
	}
	sort.Strings(paths)

	var buf bytes.Buffer
	zw := zip.NewWriter(&buf)
	h := sha256.New()
	for _, path := range paths {
		rel, err := filepath.Rel(dir, path)
		if err != nil {
			return nil, "", err
		}
		data, err := os.ReadFile(path)
		if err != nil {
			return nil, "", fmt.Errorf("read %q: %w", path, err)
		}
		fw, err := zw.Create(rel)
		if err != nil {
			return nil, "", fmt.Errorf("zip create %q: %w", rel, err)
		}
		if _, err := fw.Write(data); err != nil {
			return nil, "", fmt.Errorf("zip write %q: %w", rel, err)
		}
		// хешируем путь + содержимое для надёжной детекции изменений
		h.Write([]byte(rel))
		h.Write(data)
	}
	if err := zw.Close(); err != nil {
		return nil, "", fmt.Errorf("zip close: %w", err)
	}
	return buf.Bytes(), hex.EncodeToString(h.Sum(nil)), nil
}

// mapToStringMap конвертирует types.Map → map[string]string.
func mapToStringMap(ctx context.Context, m types.Map) (map[string]string, diag.Diagnostics) {
	if m.IsNull() || m.IsUnknown() {
		return nil, nil
	}
	elements := m.Elements()
	result := make(map[string]string, len(elements))
	var diags diag.Diagnostics
	for k, v := range elements {
		strVal, ok := v.(types.String)
		if !ok {
			diags.AddError("env_vars conversion", fmt.Sprintf("value for key %q is not a string", k))
			continue
		}
		result[k] = strVal.ValueString()
	}
	return result, diags
}