package host

import (
	"encoding/hex"
	"strings"

	"github.com/carlosframework/platform/internal/hostbox"
)

// Handles identify an inode within its filesystem across boots. Current-boot
// device, mount and inode checks still apply; handles never authorize an open.
type servingParkPersistentDirectory struct {
	Filesystem [2]int32
	Type       int32
	Handle     string
	Owner      uint32
	Mode       uint32
}

type servingParkPersistentFile servingParkPersistentDirectory

func validServingParkHandle(p servingParkPersistentDirectory) bool {
	b, err := hex.DecodeString(p.Handle)
	return err == nil && len(b) > 0 && len(b) <= 128 && hex.EncodeToString(b) == p.Handle && p.Type > 0 && p.Filesystem != [2]int32{}
}

func (p servingParkPersistentDirectory) valid() bool {
	return validServingParkHandle(p) && p.Mode&0170000 == 0040000 && p.Mode&0022 == 0
}

func (p servingParkPersistentFile) valid() bool {
	return validServingParkHandle(servingParkPersistentDirectory(p)) && p.Mode&0170000 == 0100000
}

// Historical records without handles remain readable. Partial new evidence
// refuses rather than being treated as an old record eligible for recapture.
func validateServingParkPersistentRecord(r servingParkRecord) error {
	p := r.Source.Persistent
	if p == (servingParkPersistentDirectory{}) {
		if r.Source.BootID != "" || r.EventPersistent != (servingParkPersistentDirectory{}) {
			return hostbox.ErrChanged
		}
		for _, f := range r.Source.Files {
			if f.Persistent != (servingParkPersistentFile{}) {
				return hostbox.ErrChanged
			}
		}
		return nil
	}
	if !p.valid() || !validServingParkBootID(r.Source.BootID) {
		return hostbox.ErrChanged
	}
	for _, f := range r.Source.Files {
		if f.Present {
			if !f.Persistent.valid() || f.Persistent.Filesystem != p.Filesystem {
				return hostbox.ErrChanged
			}
		} else if f.Persistent != (servingParkPersistentFile{}) {
			return hostbox.ErrChanged
		}
	}
	if r.Prepared {
		if !r.EventPersistent.valid() || r.EventPersistent.Filesystem != p.Filesystem || r.EventPersistent.Mode&0077 != 0 {
			return hostbox.ErrChanged
		}
	} else if r.EventPersistent != (servingParkPersistentDirectory{}) {
		return hostbox.ErrChanged
	}
	return nil
}

func validServingParkBootID(id string) bool {
	if len(id) != 36 || id[8] != '-' || id[13] != '-' || id[18] != '-' || id[23] != '-' {
		return false
	}
	raw := strings.ReplaceAll(id, "-", "")
	b, err := hex.DecodeString(raw)
	return err == nil && len(b) == 16 && hex.EncodeToString(b) == raw && raw != strings.Repeat("0", 32)
}

// Only the saved source decides whether persistent evidence was captured. New
// observations cannot upgrade an old intent or permanent legacy consumption.
func sameServingParkSource(saved, fresh servingParkSource) bool {
	if saved.Persistent == (servingParkPersistentDirectory{}) && saved.BootID == "" {
		for _, item := range saved.Files {
			if item.Persistent != (servingParkPersistentFile{}) {
				return false
			}
		}
		fresh.Persistent = servingParkPersistentDirectory{}
		fresh.BootID = ""
		for i := range fresh.Files {
			fresh.Files[i].Persistent = servingParkPersistentFile{}
		}
	}
	if saved.ParentPersistent == (servingParkPersistentDirectory{}) {
		fresh.ParentPersistent = servingParkPersistentDirectory{}
	}
	if saved.Volume == "" {
		fresh.Volume = ""
	}
	return saved == fresh
}