package utils

import (
	"bytes"
	"errors"
	"io"
	"os"
	"sync"
	"unsafe"
)

type BufferSize int

const (
	BufferSize1K BufferSize = 0x1 << (10 + iota)
	BufferSize2K
	BufferSize4K
	BufferSize8K
	BufferSize16K
	BufferSizeMax
)

var (
	bufferPools = map[BufferSize]*sync.Pool{
		BufferSize1K: {
			New: func() interface{} {
				return bytes.NewBuffer(make([]byte, 0, BufferSize1K))
			},
		},
		BufferSize2K: {
			New: func() interface{} {
				return bytes.NewBuffer(make([]byte, 0, BufferSize2K))
			},
		},
		BufferSize4K: {
			New: func() interface{} {
				return bytes.NewBuffer(make([]byte, 0, BufferSize4K))
			},
		},
		BufferSize8K: {
			New: func() interface{} {
				return bytes.NewBuffer(make([]byte, 0, BufferSize8K))
			},
		},
		BufferSize16K: {
			New: func() interface{} {
				return bytes.NewBuffer(make([]byte, 0, BufferSize16K))
			},
		},
	}
)

func Acquire(size BufferSize) *bytes.Buffer {
	if size <= BufferSize1K {
		size = BufferSize1K
	} else if size <= BufferSize2K {
		size = BufferSize2K
	} else if size <= BufferSize4K {
		size = BufferSize4K
	} else if size <= BufferSize8K {
		size = BufferSize8K
	} else if size <= BufferSize16K {
		size = BufferSize16K
	}

	if pool, ok := bufferPools[size]; ok {
		return pool.Get().(*bytes.Buffer)
	}

	return bytes.NewBuffer(make([]byte, 0, size))
}

func Recycle(buf *bytes.Buffer) {
	if buf == nil {
		return
	}

	var pool *sync.Pool
	size := BufferSize(buf.Cap())
	if size >= BufferSize16K {
		if size <= BufferSizeMax {
			pool = bufferPools[BufferSize16K]
		}
	} else if size >= BufferSize8K {
		pool = bufferPools[BufferSize8K]
	} else if size >= BufferSize4K {
		pool = bufferPools[BufferSize4K]
	} else if size >= BufferSize2K {
		pool = bufferPools[BufferSize2K]
	} else if size >= BufferSize1K {
		pool = bufferPools[BufferSize1K]
	}

	if pool != nil {
		buf.Reset()
		pool.Put(buf)
	}
}

func BufferedRead(name string, buf *bytes.Buffer) error {
	if buf == nil {
		return errors.New("buffer is nil")
	}

	file, err := os.Open(name)
	if err != nil {
		return err
	}
	defer file.Close()

	_, err = io.Copy(buf, file)

	return err
}

func Dup(s string) string {
	return string(unsafe.Slice(unsafe.StringData(s), len(s)))
}