package deliver

import (
	"errors"
	"fmt"
	"io"

	"github.com/tmthrgd/shm-go"
)

// SHM share memory
type SHM struct {
	rw   *shm.ReadWriteCloser
	typ  td
	data []byte
}

// Send impl interface Diliver
func (s *SHM) Send(data []byte) error {
	if 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.rw == nil {
		return nil, errors.New("please open shm consumer first")
	}

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

	return nil, err
}

// Close impl interface Deliver
func (s *SHM) Close() {
	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 {
	if m != Shm {
		fmt.Println("this is not a shm mode: ", m)
		return nil
	}

	var param []int
	for _, v := range args {
		fmt.Println(v)
		switch v.(type) {
		case int:
			param = append(param, v.(int))
		default:
			fmt.Println("shmProducer recv error parameters")

			return nil
		}
	}
	if len(param) != 2 {
		fmt.Println("shmProducer recv too much parameter: ", len(param))
		return nil
	}
	shm.Unlink(url)
	if rw, err := shm.CreateSimplex(url, 0644, param[0], param[1]); err == nil {
		fmt.Println(rw.Name())
		return &SHM{
			rw,
			agent,
			nil,
		}
	}

	fmt.Println("create simple shm error")
	return nil
}

func shmClient(m Mode, url string, args ...interface{}) *SHM {

	if m != Shm {
		fmt.Println("this is not a shm mode: ", m)
		return nil
	}

	if rw, err := shm.OpenSimplex(url); err == nil {
		return &SHM{
			rw,
			coactee,
			make([]byte, maxRecvSize),
		}
	}
	fmt.Println("shmConsumer open error")
	return nil
}