// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
//
// Copyright 2016 The Go-MySQL-Driver Authors. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at http://mozilla.org/MPL/2.0/.

package mysql

import (
	"context"
	"database/sql/driver"
	"encoding/json"
	"errors"
	"net"
	"testing"
	"time"
)

func TestInterpolateParams(t *testing.T) {
	mc := &mysqlConn{
		buf:              newBuffer(),
		maxAllowedPacket: maxPacketSize,
		cfg: &Config{
			InterpolateParams: true,
		},
	}

	q, err := mc.interpolateParams("SELECT ?+?", []driver.Value{int64(42), "gopher"})
	if err != nil {
		t.Errorf("Expected err=nil, got %#v", err)
		return
	}
	expected := `SELECT 42+'gopher'`
	if q != expected {
		t.Errorf("Expected: %q\nGot: %q", expected, q)
	}
}

func TestInterpolateParamsJSONRawMessage(t *testing.T) {
	mc := &mysqlConn{
		buf:              newBuffer(),
		maxAllowedPacket: maxPacketSize,
		cfg: &Config{
			InterpolateParams: true,
		},
	}

	buf, err := json.Marshal(struct {
		Value int `json:"value"`
	}{Value: 42})
	if err != nil {
		t.Errorf("Expected err=nil, got %#v", err)
		return
	}
	q, err := mc.interpolateParams("SELECT ?", []driver.Value{json.RawMessage(buf)})
	if err != nil {
		t.Errorf("Expected err=nil, got %#v", err)
		return
	}
	expected := `SELECT '{\"value\":42}'`
	if q != expected {
		t.Errorf("Expected: %q\nGot: %q", expected, q)
	}
}

func TestInterpolateParamsTooManyPlaceholders(t *testing.T) {
	mc := &mysqlConn{
		buf:              newBuffer(),
		maxAllowedPacket: maxPacketSize,
		cfg: &Config{
			InterpolateParams: true,
		},
	}

	q, err := mc.interpolateParams("SELECT ?+?", []driver.Value{int64(42)})
	if err != driver.ErrSkip {
		t.Errorf("Expected err=driver.ErrSkip, got err=%#v, q=%#v", err, q)
	}
}

func TestInterpolateParamsUint64(t *testing.T) {
	mc := &mysqlConn{
		buf:              newBuffer(),
		maxAllowedPacket: maxPacketSize,
		cfg: &Config{
			InterpolateParams: true,
		},
	}

	q, err := mc.interpolateParams("SELECT ?", []driver.Value{uint64(42)})
	if err != nil {
		t.Errorf("Expected err=nil, got err=%#v, q=%#v", err, q)
	}
	if q != "SELECT 42" {
		t.Errorf("Expected uint64 interpolation to work, got q=%#v", q)
	}
}

func TestCheckNamedValue(t *testing.T) {
	value := driver.NamedValue{Value: ^uint64(0)}
	mc := &mysqlConn{}
	err := mc.CheckNamedValue(&value)

	if err != nil {
		t.Fatal("uint64 high-bit not convertible", err)
	}

	if value.Value != ^uint64(0) {
		t.Fatalf("uint64 high-bit converted, got %#v %T", value.Value, value.Value)
	}
}

// TestCleanCancel tests passed context is cancelled at start.
// No packet should be sent.  Connection should keep current status.
func TestCleanCancel(t *testing.T) {
	mc := &mysqlConn{
		closech: make(chan struct{}),
	}
	mc.startWatcher()
	defer mc.cleanup()

	ctx, cancel := context.WithCancel(context.Background())
	cancel()

	for range 3 { // Repeat same behavior
		err := mc.Ping(ctx)
		if err != context.Canceled {
			t.Errorf("expected context.Canceled, got %#v", err)
		}

		if mc.closed.Load() {
			t.Error("expected mc is not closed, closed actually")
		}

		if mc.watching {
			t.Error("expected watching is false, but true")
		}
	}
}

func TestPingMarkBadConnection(t *testing.T) {
	nc := badConnection{err: errors.New("boom")}
	mc := &mysqlConn{
		netConn:          nc,
		buf:              newBuffer(),
		maxAllowedPacket: defaultMaxAllowedPacket,
		closech:          make(chan struct{}),
		cfg:              NewConfig(),
	}

	err := mc.Ping(context.Background())

	if err != driver.ErrBadConn {
		t.Errorf("expected driver.ErrBadConn, got  %#v", err)
	}
}

func TestPingErrInvalidConn(t *testing.T) {
	nc := badConnection{err: errors.New("failed to write"), n: 10}
	mc := &mysqlConn{
		netConn:          nc,
		buf:              newBuffer(),
		maxAllowedPacket: defaultMaxAllowedPacket,
		closech:          make(chan struct{}),
		cfg:              NewConfig(),
	}

	err := mc.Ping(context.Background())

	if err != nc.err {
		t.Errorf("expected %#v, got  %#v", nc.err, err)
	}
}

type badConnection struct {
	n   int
	err error
	net.Conn
}

func (bc badConnection) Write(b []byte) (n int, err error) {
	return bc.n, bc.err
}

func (bc badConnection) Close() error {
	return nil
}

func TestInterpolateParamsWithComments(t *testing.T) {
	mc := &mysqlConn{
		buf:              newBuffer(),
		maxAllowedPacket: maxPacketSize,
		cfg: &Config{
			InterpolateParams: true,
		},
	}

	tests := []struct {
		query      string
		args       []driver.Value
		expected   string
		shouldSkip bool
	}{
		// ? in single-line comment (--) should not be replaced
		{"SELECT 1 -- ?\n, ?", []driver.Value{int64(42)}, "SELECT 1 -- ?\n, 42", false},
		// ? in single-line comment (#) should not be replaced
		{"SELECT 1 # ?\n, ?", []driver.Value{int64(42)}, "SELECT 1 # ?\n, 42", false},
		// ? in multi-line comment should not be replaced
		{"SELECT /* ? */ ?", []driver.Value{int64(42)}, "SELECT /* ? */ 42", false},
		// ? in string literal should not be replaced
		{"SELECT '?', ?", []driver.Value{int64(42)}, "SELECT '?', 42", false},
		// ? in backtick identifier should not be replaced
		{"SELECT `?`, ?", []driver.Value{int64(42)}, "SELECT `?`, 42", false},
		// ? in backslash-escaped string literal should not be replaced
		{"SELECT 'C:\\path\\?x.txt', ?", []driver.Value{int64(42)}, "SELECT 'C:\\path\\?x.txt', 42", false},
		// ? in backslash-escaped string literal should not be replaced
		{"SELECT '\\'?', col FROM tbl WHERE id = ? AND desc = 'foo\\'bar?'", []driver.Value{int64(42)}, "SELECT '\\'?', col FROM tbl WHERE id = 42 AND desc = 'foo\\'bar?'", false},
		// Multiple comments and real placeholders
		{"SELECT ? -- comment ?\n, ? /* ? */ , ? # ?\n, ?", []driver.Value{int64(1), int64(2), int64(3)}, "SELECT 1 -- comment ?\n, 2 /* ? */ , 3 # ?\n, ?", true},
		// 2--1: -- followed by digit is NOT a comment (it's the number 2 minus minus 1)
		{"SELECT ?--1", []driver.Value{int64(2)}, "SELECT 2--1", false},
		// /* */*: After closing block comment, */* should NOT start a new comment
		{"SELECT /* comment */* ?, ?", []driver.Value{int64(1), int64(2)}, "SELECT /* comment */* 1, 2", false},
		// /* */*: More complex case with actual comment after
		{"SELECT /* c1 */*/* c2 */ ?, ?", []driver.Value{int64(1), int64(2)}, "SELECT /* c1 */*/* c2 */ 1, 2", false},
	}

	for i, test := range tests {

		q, err := mc.interpolateParams(test.query, test.args)
		if test.shouldSkip {
			if err != driver.ErrSkip {
				t.Errorf("Test %d: Expected driver.ErrSkip, got err=%#v, q=%#v", i, err, q)
			}
			continue
		}
		if err != nil {
			t.Errorf("Test %d: Expected err=nil, got %#v", i, err)
			continue
		}
		if q != test.expected {
			t.Errorf("Test %d: Expected: %q\nGot: %q", i, test.expected, q)
		}
	}
}

// chunkedConn is a net.Conn that serves pre-built data chunks, one per Read
// call. This simulates the behavior seen with TLS connections, where the
// server's TLS library typically produces a separate TLS record per write
// and Go's crypto/tls.Read returns one record at a time.
type chunkedConn struct {
	chunks [][]byte
	idx    int // current chunk index
	off    int // offset within current chunk
}

func (c *chunkedConn) Read(b []byte) (int, error) {
	if c.idx >= len(c.chunks) {
		return 0, errors.New("no more data")
	}
	n := copy(b, c.chunks[c.idx][c.off:])
	c.off += n
	if c.off >= len(c.chunks[c.idx]) {
		c.idx++
		c.off = 0
	}
	return n, nil
}

func (c *chunkedConn) Write(b []byte) (int, error)        { return len(b), nil } // swallow writes (e.g. COM_QUERY)
func (c *chunkedConn) Close() error                       { return nil }
func (c *chunkedConn) LocalAddr() net.Addr                { return nil }
func (c *chunkedConn) RemoteAddr() net.Addr               { return nil }
func (c *chunkedConn) SetDeadline(_ time.Time) error      { return nil }
func (c *chunkedConn) SetReadDeadline(_ time.Time) error  { return nil }
func (c *chunkedConn) SetWriteDeadline(_ time.Time) error { return nil }

var _ net.Conn = (*chunkedConn)(nil)

// makePacket wraps a payload in a MySQL protocol packet header.
func makePacket(seq byte, payload []byte) []byte {
	pkt := make([]byte, 4+len(payload))
	pkt[0] = byte(len(payload))
	pkt[1] = byte(len(payload) >> 8)
	pkt[2] = byte(len(payload) >> 16)
	pkt[3] = seq
	copy(pkt[4:], payload)
	return pkt
}

// TestGetSystemVarBufferReuse verifies that getSystemVar returns a value that
// is not corrupted by the subsequent skipRows call.
//
// The row value returned by readRow points into the read buffer. skipRows may
// call fill(), which overwrites that memory. The test feeds each protocol
// packet as a separate Read call via chunkedConn (mimicking TLS record
// boundaries), guaranteeing that fill() is called for the trailing EOF.
func TestGetSystemVarBufferReuse(t *testing.T) {
	// Protocol response for: SELECT @@max_allowed_packet → "67108864"
	//
	// Sequence numbers start at 1 (client sent COM_QUERY as seq 0).
	//
	//   seq 1: column count = 1
	//   seq 2: column definition (minimal valid)
	//   seq 3: EOF (end of column defs)
	//   seq 4: row data — length-encoded string "67108864"
	//   seq 5: EOF (end of rows)

	colCountPkt := makePacket(1, []byte{0x01})

	colDef := []byte{
		0x03, 'd', 'e', 'f', // catalog = "def"
		0x00, // schema = ""
		0x00, // table = ""
		0x00, // org_table = ""
		0x14, // name length = 20
		'@', '@', 'm', 'a', 'x', '_', 'a', 'l', 'l', 'o',
		'w', 'e', 'd', '_', 'p', 'a', 'c', 'k', 'e', 't',
		0x00,       // org_name = ""
		0x0c,       // length of fixed fields
		0x3f, 0x00, // charset = 63 (binary)
		0x14, 0x00, 0x00, 0x00, // column_length = 20
		0x0f,       // type = FIELD_TYPE_VARCHAR
		0x00, 0x00, // flags
		0x00,       // decimals
		0x00, 0x00, // filler
	}
	colDefPkt := makePacket(2, colDef)

	eof1 := makePacket(3, []byte{0xfe, 0x00, 0x00, 0x02, 0x00})

	// Row: length-encoded string "67108864" (8 bytes → length prefix 0x08)
	rowPkt := makePacket(4, []byte{0x08, '6', '7', '1', '0', '8', '8', '6', '4'})

	eof2 := makePacket(5, []byte{0xfe, 0x00, 0x00, 0x02, 0x00})

	// Each packet arrives in its own Read call, simulating TLS record
	// boundaries where each server Write becomes a separate TLS record
	// and each client Read returns exactly one record.
	conn := &chunkedConn{chunks: [][]byte{colCountPkt, colDefPkt, eof1, rowPkt, eof2}}

	mc := &mysqlConn{
		netConn:          conn,
		buf:              newBuffer(),
		cfg:              NewConfig(),
		closech:          make(chan struct{}),
		maxAllowedPacket: defaultMaxAllowedPacket,
		sequence:         1, // after COM_QUERY (seq 0)
	}

	val, err := mc.getSystemVar("max_allowed_packet")
	if err != nil {
		t.Fatalf("getSystemVar failed: %v", err)
	}

	const expected = "67108864"
	if val != expected {
		t.Fatalf("getSystemVar(max_allowed_packet) = %q, want %q", val, expected)
	}
}