package deliver

import (
	"errors"
	"fmt"
	"io"
	"reflect"
	"time"
	"unsafe"

	"basic.com/valib/shm.git"
)

// SHM share memory
type SHM struct {
	rw  *shm.ReadWriteCloser
	typ td

	recvData        []byte
	recvSliceHeader *reflect.SliceHeader
}

// Send impl interface Diliver
func (s *SHM) Send(data []byte) error {
	if s == nil || s.rw == nil {
		return errors.New("please init shm producer first")
	}

	n, err := s.rw.Write(data)
	if n < 1 {
		fmt.Println("recv data less than 1 length")
	}

	return err
}

// Recv impl interface Diliver
func (s *SHM) Recv() ([]byte, error) {

	if s == nil || s.rw == nil {
		return nil, errors.New("please open shm consumer first")
	}

	// orig

	// data := make([]byte, maxRecvSize)
	// n, err := s.rw.Read(data)
	// if err == nil || err == io.EOF {
	// 	data := data[:n:n]
	// 	return data, nil
	// }

	// cur

	// data, err := s.rw.DirectRead()
	// if err == nil || err == io.EOF {
	// 	return data, nil
	// }

	// new

	if s.recvData == nil {
		s.recvData = make([]byte, maxRecvSize)
		s.recvSliceHeader = (*reflect.SliceHeader)(unsafe.Pointer(&s.recvData))
	}
	// sliceHeader.Cap = maxRecvSize
	s.recvSliceHeader.Len = maxRecvSize

	n, err := s.rw.Read(s.recvData)
	if err == nil || err == io.EOF {
		s.recvSliceHeader.Len = n
		return s.recvData, nil
	}

	return nil, err
}

// Recv2 impl interface
func (s *SHM) Recv2(data []byte) (int, error) {
	if s == nil || s.rw == nil {
		return 0, errors.New("please open shm consumer first")
	}

	n, err := s.rw.Read(data)
	if err == nil || err == io.EOF {
		data = data[:n:n]
		return n, nil
	}

	return 0, err
}

// Close impl interface Deliver
func (s *SHM) Close() {
	if s == nil {
		return
	}
	if s.rw != nil {
		s.rw.Close()
	}
	if s.typ == agent {
		shm.Unlink(s.rw.Name())
	}
}

func shmServer(m Mode, url string, args ...interface{}) (*SHM, error) {
	if m != Shm {
		return nil, errors.New("please use deliver.Shm mode")
	}

	var param []int
	for _, v := range args {
		switch v.(type) {
		case int:
			param = append(param, v.(int))
		default:

			return nil, errors.New("shmServer created recv error parameters")
		}
	}

	blocks, size := 2, maxRecvSize
	if len(param) == 2 {
		blocks, size = param[0], param[1]
		// return nil, errors.New("shmServer created recv too much parameters")
	}

	time.Sleep(time.Millisecond)
	shm.Unlink(url)

	rw, err := shm.CreateSimplex(url, 0644, blocks, size)
	if err == nil {
		fmt.Println(rw.Name())
		return &SHM{
			rw:  rw,
			typ: agent,
		}, nil
	}

	return nil, err
}

func shmClient(m Mode, url string, args ...interface{}) (*SHM, error) {
	if m != Shm {
		return nil, errors.New("please use deliver.Shm mode")
	}

	rw, err := shm.OpenSimplex(url)
	if err == nil {
		return &SHM{
			rw:  rw,
			typ: coactee,
		}, nil
	}
	return nil, err
}