package comparison

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
)

// DestinationErrorKind identifies a comparison destination safety failure.
type DestinationErrorKind string

const (
	DestinationInvalidPath      DestinationErrorKind = "invalid_path"
	DestinationFilesystemRoot   DestinationErrorKind = "filesystem_root"
	DestinationWorkingDirectory DestinationErrorKind = "working_directory"
	DestinationSymlink          DestinationErrorKind = "symlink"
	DestinationNotDirectory     DestinationErrorKind = "not_directory"
	DestinationNotEmpty         DestinationErrorKind = "not_empty"
	DestinationUnrecognized     DestinationErrorKind = "unrecognized"
	DestinationInspection       DestinationErrorKind = "inspection"
)

// DestinationError provides inspectable context without making filesystem
// implementation details part of a manifest or command-result schema.
type DestinationError struct {
	Kind   DestinationErrorKind
	Target string
	Err    error
}

func (err *DestinationError) Error() string {
	if err.Err == nil {
		return fmt.Sprintf("comparison destination %q is %s", err.Target, err.Kind)
	}
	return fmt.Sprintf("comparison destination %q is %s: %v", err.Target, err.Kind, err.Err)
}

func (err *DestinationError) Unwrap() error {
	return err.Err
}

// DestinationPlan records a preflighted, exact bundle directory. Callers must
// pass it to Publish rather than recreating destination policy themselves.
type DestinationPlan struct {
	WorkingDirectory string
	Target           string
	Replace          bool
	state            destinationState
}

type destinationState uint8

const (
	destinationAbsent destinationState = iota
	destinationEmpty
	destinationBundle
)

// ErrUnrecognizedBundle marks a directory that is not a valid current-schema
// Weatherreporter comparison bundle.
var ErrUnrecognizedBundle = errors.New("unrecognized comparison bundle")

// PlanDestination performs the read-only comparison destination preflight.
func PlanDestination(workingDirectory, target string, replace bool) (DestinationPlan, error) {
	workingDirectory, err := absoluteCleanPath(workingDirectory)
	if err != nil {
		return DestinationPlan{}, newDestinationError(DestinationInvalidPath, workingDirectory, err)
	}
	target, err = absoluteCleanPath(target)
	if err != nil {
		return DestinationPlan{}, newDestinationError(DestinationInvalidPath, target, err)
	}
	if filepath.Dir(target) == target {
		return DestinationPlan{}, newDestinationError(DestinationFilesystemRoot, target, nil)
	}
	if target == workingDirectory {
		return DestinationPlan{}, newDestinationError(DestinationWorkingDirectory, target, nil)
	}

	plan := DestinationPlan{WorkingDirectory: workingDirectory, Target: target, Replace: replace}
	info, err := os.Lstat(target)
	if err != nil {
		if !errors.Is(err, os.ErrNotExist) {
			return DestinationPlan{}, newDestinationError(DestinationInspection, target, err)
		}
		if err := inspectMissingDestinationParent(target); err != nil {
			return DestinationPlan{}, err
		}
		return plan, nil
	}
	if info.Mode()&os.ModeSymlink != 0 {
		return DestinationPlan{}, newDestinationError(DestinationSymlink, target, nil)
	}
	if !info.IsDir() {
		return DestinationPlan{}, newDestinationError(DestinationNotDirectory, target, nil)
	}

	entries, err := os.ReadDir(target)
	if err != nil {
		return DestinationPlan{}, newDestinationError(DestinationInspection, target, err)
	}
	if len(entries) == 0 {
		plan.state = destinationEmpty
		return plan, nil
	}
	if !replace {
		return DestinationPlan{}, newDestinationError(DestinationNotEmpty, target, nil)
	}
	if _, err := RecognizeBundle(target); err != nil {
		return DestinationPlan{}, newDestinationError(DestinationUnrecognized, target, err)
	}
	plan.state = destinationBundle
	return plan, nil
}

func absoluteCleanPath(value string) (string, error) {
	if strings.TrimSpace(value) == "" {
		return "", fmt.Errorf("path is required")
	}
	if !filepath.IsAbs(value) {
		return "", fmt.Errorf("path %q must be absolute", value)
	}
	return filepath.Clean(value), nil
}

func inspectMissingDestinationParent(target string) error {
	for parent := filepath.Dir(target); ; parent = filepath.Dir(parent) {
		info, err := os.Lstat(parent)
		if err == nil {
			if info.Mode()&os.ModeSymlink != 0 {
				resolved, statErr := os.Stat(parent)
				if statErr != nil {
					return newDestinationError(DestinationInspection, target, statErr)
				}
				if !resolved.IsDir() {
					return newDestinationError(DestinationNotDirectory, target, nil)
				}
				return nil
			}
			if !info.IsDir() {
				return newDestinationError(DestinationNotDirectory, target, nil)
			}
			return nil
		}
		if !errors.Is(err, os.ErrNotExist) {
			return newDestinationError(DestinationInspection, target, err)
		}
		if filepath.Dir(parent) == parent {
			return newDestinationError(DestinationInspection, target, fmt.Errorf("no existing directory ancestor"))
		}
	}
}

func newDestinationError(kind DestinationErrorKind, target string, err error) error {
	return &DestinationError{Kind: kind, Target: target, Err: err}
}

// RecognizeBundle verifies that directory contains exactly one valid current
// comparison bundle. It never follows bundle entries through symlinks.
func RecognizeBundle(directory string) (Manifest, error) {
	info, err := os.Lstat(directory)
	if err != nil {
		return Manifest{}, unrecognizedBundleError("inspect directory", err)
	}
	if info.Mode()&os.ModeSymlink != 0 || !info.IsDir() {
		return Manifest{}, unrecognizedBundleError("directory is not a real directory", nil)
	}

	entries, err := os.ReadDir(directory)
	if err != nil {
		return Manifest{}, unrecognizedBundleError("read directory", err)
	}
	manifestData, err := readBundleFile(directory, ManifestFilename)
	if err != nil {
		return Manifest{}, err
	}
	manifest, err := decodeManifest(manifestData)
	if err != nil {
		return Manifest{}, err
	}
	if err := manifest.Validate(); err != nil {
		return Manifest{}, unrecognizedBundleError("validate manifest", err)
	}

	expected := map[string]struct{}{
		ManifestFilename:    {},
		DataPackageFilename: {},
	}
	for _, result := range manifest.Results {
		if result.Status == StatusSucceeded {
			expected[result.ReportPath] = struct{}{}
		}
	}
	if len(entries) != len(expected) {
		return Manifest{}, unrecognizedBundleError("directory entries do not match manifest", nil)
	}
	for _, entry := range entries {
		if _, ok := expected[entry.Name()]; !ok {
			return Manifest{}, unrecognizedBundleError("directory has an undeclared entry", nil)
		}
		if _, err := readBundleFile(directory, entry.Name()); err != nil {
			return Manifest{}, err
		}
	}

	dataPackage, err := readBundleFile(directory, DataPackageFilename)
	if err != nil {
		return Manifest{}, err
	}
	if SHA256(dataPackage) != manifest.DataPackage.SHA256 {
		return Manifest{}, unrecognizedBundleError("data package digest does not match manifest", nil)
	}
	return manifest, nil
}

func readBundleFile(directory, name string) ([]byte, error) {
	if !isArtifactBasename(name) {
		return nil, unrecognizedBundleError("bundle entry name is unsafe", nil)
	}
	filePath := filepath.Join(directory, name)
	info, err := os.Lstat(filePath)
	if err != nil {
		return nil, unrecognizedBundleError("inspect bundle entry", err)
	}
	if info.Mode()&os.ModeSymlink != 0 || !info.Mode().IsRegular() {
		return nil, unrecognizedBundleError("bundle entry is not a regular file", nil)
	}
	data, err := os.ReadFile(filePath)
	if err != nil {
		return nil, unrecognizedBundleError("read bundle entry", err)
	}
	return data, nil
}

func decodeManifest(data []byte) (Manifest, error) {
	decoder := json.NewDecoder(bytes.NewReader(data))
	decoder.DisallowUnknownFields()
	var manifest Manifest
	if err := decoder.Decode(&manifest); err != nil {
		return Manifest{}, unrecognizedBundleError("decode manifest", err)
	}
	var trailing any
	if err := decoder.Decode(&trailing); err != io.EOF {
		if err == nil {
			return Manifest{}, unrecognizedBundleError("manifest has multiple JSON values", nil)
		}
		return Manifest{}, unrecognizedBundleError("decode manifest", err)
	}
	return manifest, nil
}

func unrecognizedBundleError(action string, err error) error {
	if err == nil {
		return fmt.Errorf("%w: %s", ErrUnrecognizedBundle, action)
	}
	return fmt.Errorf("%w: %s: %v", ErrUnrecognizedBundle, action, err)
}

// PublicationResult describes the durable state of a publication attempt.
type PublicationResult struct {
	Committed          bool
	RetainedBackupPath string
}

// PublicationCleanupError reports that a committed bundle could not remove its
// prior sibling backup. The new bundle remains installed and the backup path
// is retained for operator recovery.
type PublicationCleanupError struct {
	RetainedBackupPath string
	Err                error
}

func (err *PublicationCleanupError) Error() string {
	return fmt.Sprintf("remove comparison backup %q: %v", err.RetainedBackupPath, err.Err)
}

func (err *PublicationCleanupError) Unwrap() error {
	return err.Err
}

// Publish writes a complete logical bundle through a private sibling directory
// and atomically installs it at a preflighted destination.
func Publish(ctx context.Context, plan DestinationPlan, bundle LogicalBundle) (PublicationResult, error) {
	return publish(ctx, plan, bundle, publishOperations{rename: os.Rename, removeAll: os.RemoveAll})
}

type publishOperations struct {
	rename       func(string, string) error
	removeAll    func(string) error
	beforeCommit func()
}

func publish(ctx context.Context, plan DestinationPlan, bundle LogicalBundle, operations publishOperations) (PublicationResult, error) {
	if operations.rename == nil {
		operations.rename = os.Rename
	}
	if operations.removeAll == nil {
		operations.removeAll = os.RemoveAll
	}
	if err := bundle.Validate(); err != nil {
		return PublicationResult{}, fmt.Errorf("validate comparison bundle: %w", err)
	}
	manifestData, err := EncodeManifest(bundle.Manifest)
	if err != nil {
		return PublicationResult{}, err
	}
	if err := ctx.Err(); err != nil {
		return PublicationResult{}, err
	}
	plan, err = PlanDestination(plan.WorkingDirectory, plan.Target, plan.Replace)
	if err != nil {
		return PublicationResult{}, err
	}

	if err := os.MkdirAll(filepath.Dir(plan.Target), 0o755); err != nil {
		return PublicationResult{}, fmt.Errorf("create comparison destination parent %q: %w", filepath.Dir(plan.Target), err)
	}
	temporaryDirectory, err := os.MkdirTemp(filepath.Dir(plan.Target), "."+filepath.Base(plan.Target)+".staging-")
	if err != nil {
		return PublicationResult{}, fmt.Errorf("create comparison staging directory: %w", err)
	}
	if err := os.Chmod(temporaryDirectory, 0o700); err != nil {
		os.RemoveAll(temporaryDirectory)
		return PublicationResult{}, fmt.Errorf("secure comparison staging directory: %w", err)
	}
	defer func() {
		if temporaryDirectory != "" {
			_ = os.RemoveAll(temporaryDirectory)
		}
	}()

	if err := writeLogicalBundle(ctx, temporaryDirectory, bundle, manifestData); err != nil {
		return PublicationResult{}, err
	}

	currentPlan, err := PlanDestination(plan.WorkingDirectory, plan.Target, plan.Replace)
	if err != nil {
		return PublicationResult{}, err
	}
	if operations.beforeCommit != nil {
		operations.beforeCommit()
	}
	if err := ctx.Err(); err != nil {
		return PublicationResult{}, err
	}
	if currentPlan.state == destinationAbsent {
		if err := operations.rename(temporaryDirectory, currentPlan.Target); err != nil {
			return PublicationResult{}, fmt.Errorf("publish comparison bundle to %q: %w", currentPlan.Target, err)
		}
		temporaryDirectory = ""
		return PublicationResult{Committed: true}, nil
	}

	backupDirectory, err := uniqueSiblingPath(filepath.Dir(currentPlan.Target), "."+filepath.Base(currentPlan.Target)+".backup-")
	if err != nil {
		return PublicationResult{}, err
	}
	if err := operations.rename(currentPlan.Target, backupDirectory); err != nil {
		return PublicationResult{}, fmt.Errorf("back up comparison destination %q: %w", currentPlan.Target, err)
	}
	if err := authorizeMovedDestination(currentPlan, backupDirectory); err != nil {
		return PublicationResult{}, restoreMovedDestination(operations, backupDirectory, currentPlan.Target, err)
	}
	if err := operations.rename(temporaryDirectory, currentPlan.Target); err != nil {
		return PublicationResult{}, restoreMovedDestination(operations, backupDirectory, currentPlan.Target, fmt.Errorf("replace comparison destination %q: %w", currentPlan.Target, err))
	}
	temporaryDirectory = ""
	if err := operations.removeAll(backupDirectory); err != nil {
		cleanupErr := &PublicationCleanupError{RetainedBackupPath: backupDirectory, Err: err}
		return PublicationResult{Committed: true, RetainedBackupPath: backupDirectory}, cleanupErr
	}
	return PublicationResult{Committed: true}, nil
}

func authorizeMovedDestination(plan DestinationPlan, backupDirectory string) error {
	backupPlan, err := PlanDestination(plan.WorkingDirectory, backupDirectory, plan.Replace)
	if err != nil {
		return fmt.Errorf("authorize moved comparison destination %q: %w", backupDirectory, err)
	}
	if backupPlan.state != destinationEmpty && backupPlan.state != destinationBundle {
		return fmt.Errorf("authorize moved comparison destination %q: destination disappeared", backupDirectory)
	}
	return nil
}

func restoreMovedDestination(operations publishOperations, backupDirectory, target string, cause error) error {
	if _, err := os.Lstat(target); err == nil {
		return errors.Join(
			cause,
			fmt.Errorf("restore prior comparison destination from %q: destination %q reappeared", backupDirectory, target),
		)
	} else if !errors.Is(err, os.ErrNotExist) {
		return errors.Join(
			cause,
			fmt.Errorf("inspect comparison destination %q before restoring from %q: %w", target, backupDirectory, err),
		)
	}
	if restoreErr := operations.rename(backupDirectory, target); restoreErr != nil {
		return errors.Join(
			cause,
			fmt.Errorf("restore prior comparison destination from %q: %w", backupDirectory, restoreErr),
		)
	}
	return cause
}

func writeLogicalBundle(ctx context.Context, directory string, bundle LogicalBundle, manifestData []byte) error {
	if err := writeBundleFile(ctx, filepath.Join(directory, DataPackageFilename), bundle.DataPackage); err != nil {
		return err
	}
	for _, report := range bundle.Reports {
		if err := writeBundleFile(ctx, filepath.Join(directory, report.Path), report.Markdown); err != nil {
			return err
		}
	}
	if err := writeBundleFile(ctx, filepath.Join(directory, ManifestFilename), manifestData); err != nil {
		return err
	}
	return nil
}

func writeBundleFile(ctx context.Context, filePath string, content []byte) error {
	if err := ctx.Err(); err != nil {
		return err
	}
	file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)
	if err != nil {
		return fmt.Errorf("create comparison bundle file %q: %w", filePath, err)
	}
	if _, err := file.Write(content); err != nil {
		file.Close()
		return fmt.Errorf("write comparison bundle file %q: %w", filePath, err)
	}
	if err := file.Close(); err != nil {
		return fmt.Errorf("close comparison bundle file %q: %w", filePath, err)
	}
	return nil
}

func uniqueSiblingPath(parent, prefix string) (string, error) {
	file, err := os.CreateTemp(parent, prefix)
	if err != nil {
		return "", fmt.Errorf("reserve comparison backup path: %w", err)
	}
	path := file.Name()
	if err := file.Close(); err != nil {
		os.Remove(path)
		return "", fmt.Errorf("close comparison backup reservation: %w", err)
	}
	if err := os.Remove(path); err != nil {
		return "", fmt.Errorf("release comparison backup reservation: %w", err)
	}
	return path, nil
}