// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build (darwin && !ios) || dragonfly || freebsd || solaris

package net

import (
	"errors"
	"io"
	"io/fs"
	"syscall"
	"testing"
	"time"
)

type sendFileMocker struct {
	cursor  int64
	content []byte

	seekInvoked        bool
	syscallConnInvoked bool
}

var _ fs.File = (*sendFileMocker)(nil)
var _ syscall.Conn = (*sendFileMocker)(nil)

func TestSendFileWorksOnNonOsFilesToo(t *testing.T) {
	ln, err := Listen("tcp", ":0")
	if err != nil {
		t.Fatal(err)
	}
	defer ln.Close()

	go func() {
		conn, err := ln.Accept()
		if err != nil {
			panic(err)
		}
		_, _ = io.Copy(io.Discard, conn)
	}()

	c, err := Dial("tcp", ln.Addr().String())
	if err != nil {
		t.Fatal(err)
	}
	defer c.Close()

	sfm := &sendFileMocker{content: []byte("abcdefghijklmno")}

	tcpConn := c.(*TCPConn)
	_, err, _ = sendFile(tcpConn.fd, sfm)
	if err == nil || err.Error() != "purposefully not available" {
		t.Fatal("Purposefully expected .SyscallConn to return an error")
	}

	// After this invocation, sfm's variables must be set to true.
	if !sfm.seekInvoked {
		t.Error(".Seek was not invoked!")
	}
	if !sfm.syscallConnInvoked {
		t.Error(".SyscallConn was not invoked!")
	}
}

func (sfm *sendFileMocker) SyscallConn() (syscall.RawConn, error) {
	sfm.syscallConnInvoked = true
	return nil, errors.New("purposefully not available")
}

func (sfm *sendFileMocker) Seek(offset int64, whence int) (int64, error) {
	sfm.seekInvoked = true
	if whence == io.SeekEnd {
		offset = -offset
	} else if whence == io.SeekStart {
		sfm.cursor = 0
	}
	sfm.cursor += offset
	return sfm.cursor, nil
}

func (sfm *sendFileMocker) Size() int64 {
	return int64(len(sfm.content))
}

func (sfm *sendFileMocker) Close() error {
	return nil
}

func (sfm *sendFileMocker) Stat() (fs.FileInfo, error) {
	return &mockFileInfo{sfm.Size()}, nil
}

type mockFileInfo struct{ size int64 }

var _ fs.FileInfo = (*mockFileInfo)(nil)

func (mfi *mockFileInfo) Name() string       { return "in-memory" }
func (mfi *mockFileInfo) Size() int64        { return mfi.size }
func (mfi *mockFileInfo) IsDir() bool        { return false }
func (mfi *mockFileInfo) Sys() any           { return nil }
func (mfi *mockFileInfo) Mode() fs.FileMode  { return 0 }
func (mfi *mockFileInfo) ModTime() time.Time { return time.Now() }

func (sfm *sendFileMocker) Read(b []byte) (int, error) {
	n := copy(b, sfm.content[sfm.cursor:])
	return n, nil
}