package shm

import (
	"fmt"
	"unsafe"

	"bash_go_service/config-loader/internal/models"
	"bash_go_service/shared/pkg/constants"
	"bash_go_service/shared/pkg/logger"

	"golang.org/x/sys/unix"
)

// shmget 调用系统调用 SYS_SHMGET 创建或获取共享内存段
// key: 共享内存的键值
// size: 共享内存的大小
// shmflg: 标志位，用于指定权限和行为
func shmget(key int, size int, shmflg int) (int, error) {
	id, _, errno := unix.Syscall(unix.SYS_SHMGET, uintptr(key), uintptr(size), uintptr(shmflg))
	if errno != 0 {
		return 0, errno
	}
	return int(id), nil
}

// shmat 调用系统调用 SYS_SHMAT 将共享内存段附加到进程的地址空间
// shmid: 共享内存段的 ID
// shmaddr: 指定的附加地址（通常为 0 表示系统自动选择）
// shmflg: 标志位，用于指定附加模式
func shmat(shmid int, shmaddr uintptr, shmflg int) (unsafe.Pointer, error) {
	addr, _, errno := unix.Syscall(unix.SYS_SHMAT, uintptr(shmid), shmaddr, uintptr(shmflg))
	if errno != 0 {
		return nil, errno
	}
	return unsafe.Pointer(addr), nil
}

// shmdt 调用系统调用 SYS_SHMDT 将共享内存段从进程的地址空间分离
// shmaddr: 共享内存段的地址
func shmdt(shmaddr unsafe.Pointer) error {
	_, _, errno := unix.Syscall(unix.SYS_SHMDT, uintptr(shmaddr), 0, 0)
	if errno != 0 {
		return errno
	}
	return nil
}

// WriteConfigToSharedMemory 将配置数据写入共享内存
// config: 要写入的配置数据
func WriteConfigToSharedMemory(config *models.ConfigData) error {
	logger.Debug("Starting to write configuration to shared memory")

	// 使用 unsafe.Alignof 获取对齐要求
	align := unsafe.Alignof(*config)
	size := unsafe.Sizeof(*config)

	// 确保大小是对齐的
	alignedSize := (size + align - 1) &^ (align - 1)

	if alignedSize > constants.ShmSize {
		return fmt.Errorf("config size %d exceeds shared memory size %d", alignedSize, constants.ShmSize)
	}

	// 创建共享内存
	shmID, err := shmget(constants.ShmKey, int(alignedSize), unix.IPC_CREAT|0666)
	if err != nil {
		// 获取更详细的错误信息
		switch err {
		case unix.EACCES:
			logger.Error("Permission denied: %v", err)
		case unix.EEXIST:
			logger.Error("Shared memory segment already exists: %v", err)
		case unix.EINVAL:
			logger.Error("Invalid size or key: %v", err)
		case unix.ENOENT:
			logger.Error("Shared memory segment does not exist: %v", err)
		case unix.ENOMEM:
			logger.Error("No memory available: %v", err)
		default:
			logger.Error("Unknown error: %v", err)
		}
		return fmt.Errorf("shmget failed: %w", err)
	}

	// 附加共享内存
	shmPtr, err := shmat(shmID, 0, 0)
	if err != nil {
		return fmt.Errorf("shmat failed: %w", err)
	}
	defer shmdt(shmPtr)

	// 使用内存屏障确保对齐
	alignedPtr := unsafe.Pointer((uintptr(shmPtr) + align - 1) &^ (align - 1))

	// 复制数据
	*(*models.ConfigData)(alignedPtr) = *config

	logger.Info("Configuration successfully written to shared memory")
	return nil
}

// ReadConfigFromSharedMemory 从共享内存读取配置数据
func ReadConfigFromSharedMemory() (*models.ConfigData, error) {
	logger.Debug("Starting to read configuration from shared memory")

	// 获取共享内存段
	shmID, err := shmget(constants.ShmKey, constants.ShmSize, unix.IPC_CREAT|0640)
	if err != nil {
		return nil, fmt.Errorf("shmget failed: %w", err)
	}

	// 将共享内存段附加到进程地址空间（只读模式）
	shmPtr, err := shmat(shmID, 0, unix.SHM_RDONLY)
	if err != nil {
		return nil, fmt.Errorf("shmat failed: %w", err)
	}
	defer shmdt(shmPtr) // 确保在函数结束时分离共享内存

	// 创建一个新的配置数据对象
	config := new(models.ConfigData)
	configSize := unsafe.Sizeof(*config)
	if configSize > constants.ShmSize {
		return nil, fmt.Errorf("configuration size (%d) exceeds shared memory size (%d)", configSize, constants.ShmSize)
	}

	// 从共享内存复制数据到配置对象
	copy((*[constants.ShmSize]byte)(unsafe.Pointer(config))[:], (*[constants.ShmSize]byte)(shmPtr)[:])

	logger.Info("Configuration successfully read from shared memory")
	return config, nil
}