package shmqueue

import (
    "context"
    "fmt"
    "time"
    "github.com/gen2brain/shm"
)

// NewBlock shm block with size
func NewBlock(size int, key int) ([]byte, int, error) {
    id, err := shm.Get(key, size, shm.IPC_CREAT|0666)
    fmt.Println("Get:", id, err)
    if err != nil || id == -1 {
        return nil, -1, err
    }

    data, err2 := shm.At(id, 0, 0)
    if err2 != nil {
        return nil, -1, err2
    }

    return data, id, nil
}

// AttachBlock attach exist shm
func AttachBlock(key int) ([]byte, int, error) {
    id, err := shm.Get(key, 0, 0)
    fmt.Println("Get:", id, err)
    if err != nil || id == -1 { //no exist
        return nil, -1, err
    }

    data, err2 := shm.At(id, 0, 0)
    if err2 != nil {
        return nil, -1, err2
    }

    return data, id, nil
}

// ReleaseBlock release shm block
func ReleaseBlock(data []byte) {
    if data != nil {
        shm.Dt(data)
    }
}

// CreateRawShm create raw shm block with size, only space, no padding, return data([]byte), id(int)
// context for quit
func CreateRawShm(ctx context.Context, size int, key int) ([]byte, int) {
    data, id, err := AttachBlock(key)
    fmt.Println("err:", err)
    if err != nil {
    loopB:
        for {
            select {
            case <-ctx.Done():
                return nil, -1
            default:
                if err == nil {
                    break loopB
                } else {
                    fmt.Println("createShm error:", err)
                }
                time.Sleep(time.Millisecond)
                data, id, err = NewBlock(size, key)
            }
        }
    }
    return data, id
}

//AttachRawShm don't create
func AttachRawShm(ctx context.Context, key int) ([]byte, int) {
    data, id, err := AttachBlock(key)
    if err != nil {
    loopB:
        for {
            select {
            case <-ctx.Done():
                return nil, -1
            default:
                if err == nil {
                    break loopB
                } else {
                    fmt.Println("createShm error:", err)
                }
                time.Sleep(time.Millisecond)
                data, id, err = AttachBlock(key)
            }
        }
    }
    return data, id
}

// CreatePaddingShm create padding shm block with size, return data-with-padding([]byte), id(int)
// context for quit, padding for fill raw shm block
func CreatePaddingShm(ctx context.Context, size int, key int, padding []byte) ([]byte, int) {
    data, id, err := NewBlock(size, key)
    if err != nil {
    loopB:
        for {
            select {
            case <-ctx.Done():
                return nil, -1
            default:
                if err == nil {
                    break loopB
                } else {
                    fmt.Println("createShm error:", err)
                }
                time.Sleep(time.Millisecond)
                data, id, err = NewBlock(size, key)
            }
        }
    }

    copy(data, padding)
    return data, id
}

// DetachShm destroy
func DetachShm(data []byte) {
    ReleaseBlock(data)
}

// Attach attach shmid get block
func Attach(id int) ([]byte, error) {
   return shm.At(id, 0, 0)
}

// Detach detach shm block
func Detach(d []byte) error {
   return shm.Dt(d)
}

// RemoveShmID Remove shmid
func RemoveShmID(id int) error {
   return shm.Rm(id)
}