// Copyright (c) 2018 David Crawshaw <david@zentus.com>
// Copyright (c) 2021 Ross Light <ross@zombiezen.com>
//
// Permission to use, copy, modify, and distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// SPDX-License-Identifier: ISC

package sqlite

import (
	"errors"
	"fmt"
	"io"
	"unsafe"

	"modernc.org/libc"
	lib "modernc.org/sqlite/lib"
)

const blobBufSize = 4096

var (
	mainCString = mustCString("main")
	tempCString = mustCString("temp")
)

// OpenBlob opens a blob in a particular {database,table,column,row}.
//
// https://www.sqlite.org/c3ref/blob_open.html
func (c *Conn) OpenBlob(dbn, table, column string, row int64, write bool) (*Blob, error) {
	if c == nil {
		return nil, fmt.Errorf("sqlite: open blob %q.%q: nil connection", table, column)
	}
	return c.openBlob(dbn, table, column, row, write)
}

func (c *Conn) openBlob(dbn, table, column string, row int64, write bool) (_ *Blob, err error) {
	var cdb uintptr
	switch dbn {
	case "", "main":
		cdb = mainCString
	case "temp":
		cdb = tempCString
	default:
		var err error
		cdb, err = libc.CString(dbn)
		if err != nil {
			return nil, fmt.Errorf("sqlite: open blob %q.%q: %w", table, column, err)
		}
		defer libc.Xfree(c.tls, cdb)
	}
	var writeFlag int32
	if write {
		writeFlag = 1
	}
	buf, err := malloc(c.tls, blobBufSize)
	if err != nil {
		return nil, fmt.Errorf("sqlite: open blob %q.%q: %w", table, column, err)
	}
	defer func() {
		if err != nil {
			libc.Xfree(c.tls, buf)
		}
	}()

	ctable, err := libc.CString(table)
	if err != nil {
		return nil, fmt.Errorf("sqlite: open blob %q.%q: %w", table, column, err)
	}
	defer libc.Xfree(c.tls, ctable)
	ccolumn, err := libc.CString(column)
	if err != nil {
		return nil, fmt.Errorf("sqlite: open blob %q.%q: %w", table, column, err)
	}
	defer libc.Xfree(c.tls, ccolumn)

	blobPtrPtr, err := malloc(c.tls, ptrSize)
	if err != nil {
		return nil, fmt.Errorf("sqlite: open blob %q.%q: %w", table, column, err)
	}
	defer libc.Xfree(c.tls, blobPtrPtr)
	for {
		if err := c.interrupted(); err != nil {
			return nil, fmt.Errorf("sqlite: open blob %q.%q: %w", table, column, err)
		}
		res := ResultCode(lib.Xsqlite3_blob_open(
			c.tls,
			c.conn,
			cdb,
			ctable,
			ccolumn,
			row,
			writeFlag,
			blobPtrPtr,
		))
		switch res {
		case ResultLockedSharedCache:
			if err := reserr(waitForUnlockNotify(c.tls, c.conn, c.unlockNote)); err != nil {
				return nil, fmt.Errorf("sqlite: open blob %q.%q: %w", table, column, err)
			}
			// loop
		case ResultOK:
			blobPtr := *(*uintptr)(unsafe.Pointer(blobPtrPtr))
			return &Blob{
				conn: c,
				blob: blobPtr,
				buf:  buf,
				size: lib.Xsqlite3_blob_bytes(c.tls, blobPtr),
			}, nil
		default:
			return nil, fmt.Errorf("sqlite: open blob %q.%q: %w", table, column, c.extreserr(res))
		}
	}
}

// Blob provides streaming access to SQLite blobs.
type Blob struct {
	conn *Conn
	blob uintptr
	buf  uintptr
	off  int32
	size int32
}

func (blob *Blob) bufSlice() []byte {
	return libc.GoBytes(blob.buf, blobBufSize)
}

// Read reads up to len(p) bytes from the blob into p.
// https://www.sqlite.org/c3ref/blob_read.html
func (blob *Blob) Read(p []byte) (int, error) {
	if blob.blob == 0 {
		return 0, fmt.Errorf("sqlite: read blob: %w", errInvalidBlob)
	}
	if blob.off >= blob.size {
		return 0, io.EOF
	}
	if err := blob.conn.interrupted(); err != nil {
		return 0, fmt.Errorf("sqlite: read blob: %w", err)
	}
	if rem := blob.size - blob.off; len(p) > int(rem) {
		p = p[:rem]
	}
	fullLen := len(p)
	for len(p) > 0 {
		nn := int32(blobBufSize)
		if int(nn) > len(p) {
			nn = int32(len(p))
		}
		res := ResultCode(lib.Xsqlite3_blob_read(blob.conn.tls, blob.blob, blob.buf, nn, blob.off))
		if err := reserr(res); err != nil {
			return fullLen - len(p), fmt.Errorf("sqlite: read blob: %w", err)
		}
		copy(p, blob.bufSlice()[:int(nn)])
		p = p[nn:]
		blob.off += nn
	}
	return fullLen, nil
}

// WriteTo copies the blob to w until there's no more data to write or
// an error occurs.
func (blob *Blob) WriteTo(w io.Writer) (n int64, err error) {
	if blob.blob == 0 {
		return 0, fmt.Errorf("sqlite: read blob: %w", errInvalidBlob)
	}
	if blob.off >= blob.size {
		return 0, nil
	}
	if err := blob.conn.interrupted(); err != nil {
		return 0, fmt.Errorf("sqlite: read blob: %w", err)
	}
	for blob.off < blob.size {
		buf := blob.bufSlice()
		if remaining := int(blob.size - blob.off); len(buf) > remaining {
			buf = buf[:remaining]
		}
		res := ResultCode(lib.Xsqlite3_blob_read(blob.conn.tls, blob.blob, blob.buf, int32(len(buf)), blob.off))
		if err := reserr(res); err != nil {
			return n, fmt.Errorf("sqlite: read blob: %w", err)
		}
		nn, err := w.Write(buf)
		blob.off += int32(nn)
		n += int64(nn)
		if err != nil {
			return n, err
		}
	}
	return n, nil
}

// Write writes len(p) from p to the blob.
// https://www.sqlite.org/c3ref/blob_write.html
func (blob *Blob) Write(p []byte) (int, error) {
	if blob.blob == 0 {
		return 0, fmt.Errorf("sqlite: write blob: %w", errInvalidBlob)
	}
	if err := blob.conn.interrupted(); err != nil {
		return 0, fmt.Errorf("sqlite: write blob: %w", err)
	}
	fullLen := len(p)
	for len(p) > 0 {
		nn := copy(blob.bufSlice(), p)
		res := ResultCode(lib.Xsqlite3_blob_write(blob.conn.tls, blob.blob, blob.buf, int32(nn), blob.off))
		if err := reserr(res); err != nil {
			return fullLen - len(p), fmt.Errorf("sqlite: write blob: %w", err)
		}
		p = p[nn:]
		blob.off += int32(nn)
	}
	return fullLen, nil
}

// WriteString writes s to the blob.
// https://www.sqlite.org/c3ref/blob_write.html
func (blob *Blob) WriteString(s string) (int, error) {
	if blob.blob == 0 {
		return 0, fmt.Errorf("sqlite: write blob: %w", errInvalidBlob)
	}
	if err := blob.conn.interrupted(); err != nil {
		return 0, fmt.Errorf("sqlite: write blob: %w", err)
	}
	fullLen := len(s)
	for len(s) > 0 {
		nn := copy(blob.bufSlice(), s)
		res := ResultCode(lib.Xsqlite3_blob_write(blob.conn.tls, blob.blob, blob.buf, int32(nn), blob.off))
		if err := reserr(res); err != nil {
			return fullLen - len(s), fmt.Errorf("sqlite: write blob: %w", err)
		}
		s = s[nn:]
		blob.off += int32(nn)
	}
	return fullLen, nil
}

// ReadFrom copies data from r to the blob until EOF or error.
func (blob *Blob) ReadFrom(r io.Reader) (n int64, err error) {
	if blob.blob == 0 {
		return 0, fmt.Errorf("sqlite: write blob: %w", errInvalidBlob)
	}
	if err := blob.conn.interrupted(); err != nil {
		return 0, fmt.Errorf("sqlite: write blob: %w", err)
	}
	for {
		nn, err := r.Read(blob.bufSlice())
		if nn > 0 {
			res := ResultCode(lib.Xsqlite3_blob_write(blob.conn.tls, blob.blob, blob.buf, int32(nn), blob.off))
			if err := reserr(res); err != nil {
				return n, fmt.Errorf("sqlite: write blob: %w", err)
			}
			n += int64(nn)
			blob.off += int32(nn)
		}
		if err != nil {
			if err == io.EOF {
				err = nil
			}
			return n, err
		}
	}
}

// Seek sets the offset for the next Read or Write and returns the offset.
// Seeking past the end of the blob returns an error.
func (blob *Blob) Seek(offset int64, whence int) (int64, error) {
	switch whence {
	case io.SeekStart:
		// use offset directly
	case io.SeekCurrent:
		offset += int64(blob.off)
	case io.SeekEnd:
		offset += int64(blob.size)
	default:
		return int64(blob.off), fmt.Errorf("sqlite: seek blob: invalid whence %d", whence)
	}
	if offset < 0 {
		return int64(blob.off), fmt.Errorf("sqlite: seek blob: negative offset %d", offset)
	}
	if offset > int64(blob.size) {
		return int64(blob.off), fmt.Errorf("sqlite: seek blob: offset %d is past size %d", offset, blob.size)
	}
	blob.off = int32(offset)
	return offset, nil
}

// Size returns the number of bytes in the blob.
func (blob *Blob) Size() int64 {
	return int64(blob.size)
}

// Close releases any resources associated with the blob handle.
// https://www.sqlite.org/c3ref/blob_close.html
func (blob *Blob) Close() error {
	if blob.blob == 0 {
		return errInvalidBlob
	}
	libc.Xfree(blob.conn.tls, blob.buf)
	blob.buf = 0
	res := ResultCode(lib.Xsqlite3_blob_close(blob.conn.tls, blob.blob))
	blob.blob = 0
	if err := reserr(res); err != nil {
		return fmt.Errorf("sqlite: close blob: %w", err)
	}
	return nil
}

var errInvalidBlob = errors.New("invalid blob")

// TODO: Blob Reopen