package fetch

import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"time"

	oid "lindenii.org/go/furgit/object/id"
	"lindenii.org/go/furgit/object/tree"
	"lindenii.org/go/furgit/object/tree/mode"
)

// TreeFS exposes one Git tree as an fs.FS view backed by a Fetcher.
//
// TreeFS interprets names using io/fs path rules.
// Those rules do not match raw Git tree entry naming exactly:
// names are UTF-8, slash-separated, and must be valid fs.FS paths.
// Tree entries that cannot be represented under those rules
// are not addressable through this API.
//
// Labels: MT-Safe.
type TreeFS struct {
	fetcher   *Fetcher
	rootTree  oid.ObjectID
	rootEntry *tree.Entry
}

var (
	_ fs.FS         = (*TreeFS)(nil)
	_ fs.ReadFileFS = (*TreeFS)(nil)
	_ fs.ReadDirFS  = (*TreeFS)(nil)
	_ fs.StatFS     = (*TreeFS)(nil)
	_ fs.SubFS      = (*TreeFS)(nil)
)

// ErrGitlinkNotFile reports that
// a gitlink (submodule) entry was opened or read as a file.
// It wraps [fs.ErrInvalid] so that
// generic fs consumers classify it correctly.
var ErrGitlinkNotFile = fmt.Errorf("%w: object/fetch: gitlink entries are not readable as files", fs.ErrInvalid)

// ErrIsDirectory reports that
// a directory entry was read as a file.
// It wraps [fs.ErrInvalid] so that
// generic fs consumers classify it correctly.
var ErrIsDirectory = fmt.Errorf("%w: object/fetch: is a directory", fs.ErrInvalid)

func splitPath(path string) [][]byte {
	if len(path) == 0 {
		return nil
	}

	return bytes.Split([]byte(path), []byte("/"))
}

type treeEntryValue struct {
	name      string
	mode      mode.Mode
	objectID  oid.ObjectID
	treeID    oid.ObjectID
	treeEntry *tree.Entry
}

func (entry treeEntryValue) isDir() bool {
	return entry.mode == mode.Directory
}

func (entry treeEntryValue) blobSize(fetcher *Fetcher) (int, error) {
	return fetcher.Size(entry.objectID)
}

func (entry treeEntryValue) subtreeID() (oid.ObjectID, error) {
	if entry.name == "." {
		return entry.treeID, nil
	}

	if entry.mode != mode.Directory {
		return oid.ObjectID{}, fmt.Errorf("object/fetch: path %q is not a tree", entry.name) //nolint:err113 // Never user-visible.
	}

	return entry.objectID, nil
}

type treeFSInfo struct {
	name  string
	mode  fs.FileMode
	size  int64
	sys   any
	isDir bool
}

var (
	_ fs.FileInfo = (*treeFSInfo)(nil)
	_ fs.DirEntry = (*treeFSInfo)(nil)
)

func (info *treeFSInfo) Name() string       { return info.name }
func (info *treeFSInfo) Size() int64        { return info.size }
func (info *treeFSInfo) Mode() fs.FileMode  { return info.mode }
func (info *treeFSInfo) Type() fs.FileMode  { return info.mode.Type() }
func (info *treeFSInfo) IsDir() bool        { return info.isDir }
func (info *treeFSInfo) ModTime() time.Time { return time.Time{} }
func (info *treeFSInfo) Sys() any           { return info.sys }
func (info *treeFSInfo) Info() (fs.FileInfo, error) {
	return info, nil
}

func treeFSEntryMode(mod mode.Mode) fs.FileMode {
	switch mod {
	case mode.Directory:
		return fs.ModeDir | 0o555
	case mode.Regular:
		return 0o444
	case mode.Executable:
		return 0o555
	case mode.Symlink:
		return fs.ModeSymlink | 0o444
	case mode.Gitlink:
		return fs.ModeIrregular
	default:
		return fs.ModeIrregular
	}
}

// TreeFS returns a new filesystem view rooted at root, which may be any
// tree-ish object accepted by PeelToTreeID.
//
// Labels: Deps-Borrowed, Life-Parent.
func (fetcher *Fetcher) TreeFS(root oid.ObjectID) (*TreeFS, error) {
	rootTree, err := fetcher.PeelToTreeID(root)
	if err != nil {
		return nil, err
	}

	return &TreeFS{
		fetcher:  fetcher,
		rootTree: rootTree,
	}, nil
}

type treeFSOp uint8

const (
	treeFSOpOpen treeFSOp = iota
	treeFSOpReadFile
	treeFSOpReadDir
	treeFSOpStat
	treeFSOpSub
)

func (op treeFSOp) pathErrorOp() string {
	switch op {
	case treeFSOpOpen:
		return "open"
	case treeFSOpReadFile:
		return "readfile"
	case treeFSOpReadDir:
		return "readdir"
	case treeFSOpStat:
		return "stat"
	case treeFSOpSub:
		return "sub"
	default:
		return "treefs"
	}
}

// Open opens name for reading.
//
// Directories are returned as fs.ReadDirFile values. Gitlink entries are not
// readable through TreeFS.
func (treeFS *TreeFS) Open(name string) (fs.File, error) {
	entry, err := treeFS.resolvePath(treeFSOpOpen, name)
	if err != nil {
		return nil, err
	}

	info, err := treeFS.statEntry(entry)
	if err != nil {
		return nil, treeFSPathError(treeFSOpOpen, name, err)
	}

	if entry.isDir() {
		treeID, err := entry.subtreeID()
		if err != nil {
			return nil, treeFSPathError(treeFSOpOpen, name, err)
		}

		tree, err := treeFS.fetcher.ExactTree(treeID)
		if err != nil {
			return nil, treeFSPathError(treeFSOpOpen, name, err)
		}

		entries := make([]fs.DirEntry, 0, len(tree.Object().Entries()))
		for _, child := range tree.Object().Entries() {
			childEntry := treeEntryValue{
				name:      string(child.Name),
				mode:      child.Mode,
				objectID:  child.ID,
				treeEntry: &child,
			}

			childInfo, err := treeFS.statEntry(childEntry)
			if err != nil {
				return nil, treeFSPathError(treeFSOpOpen, name, err)
			}

			entries = append(entries, childInfo)
		}

		return &treeFSDir{
			info:    info,
			entries: entries,
		}, nil
	}

	if entry.mode == mode.Gitlink {
		return nil, treeFSPathError(treeFSOpOpen, name, ErrGitlinkNotFile)
	}

	reader, _, err := treeFS.fetcher.ExactBlobReader(entry.objectID)
	if err != nil {
		return nil, treeFSPathError(treeFSOpOpen, name, err)
	}

	return &treeFSBlob{
		info:   info,
		reader: reader,
	}, nil
}

type treeFSBlob struct {
	info   *treeFSInfo
	reader io.ReadCloser
}

var _ fs.File = (*treeFSBlob)(nil)

func (file *treeFSBlob) Stat() (fs.FileInfo, error) { return file.info, nil }
func (file *treeFSBlob) Read(p []byte) (int, error) { return file.reader.Read(p) }
func (file *treeFSBlob) Close() error               { return file.reader.Close() }

type treeFSDir struct {
	info    *treeFSInfo
	entries []fs.DirEntry
	offset  int
}

var (
	_ fs.File        = (*treeFSDir)(nil)
	_ fs.ReadDirFile = (*treeFSDir)(nil)
)

func (dir *treeFSDir) Stat() (fs.FileInfo, error) { return dir.info, nil }
func (dir *treeFSDir) Close() error               { return nil }

func (dir *treeFSDir) Read(_ []byte) (int, error) {
	return 0, fs.ErrInvalid
}

func (dir *treeFSDir) ReadDir(n int) ([]fs.DirEntry, error) {
	if dir.offset >= len(dir.entries) && n > 0 {
		return nil, io.EOF
	}

	if n <= 0 {
		out := append([]fs.DirEntry(nil), dir.entries[dir.offset:]...)
		dir.offset = len(dir.entries)

		return out, nil
	}

	end := min(dir.offset+n, len(dir.entries))

	out := append([]fs.DirEntry(nil), dir.entries[dir.offset:end]...)
	dir.offset = end

	return out, nil
}

func treeFSValidPath(name string) bool {
	return name == "." || fs.ValidPath(name)
}

func treeFSPathError(op treeFSOp, path string, err error) error {
	return &fs.PathError{Op: op.pathErrorOp(), Path: path, Err: err}
}

// ReadDir reads and returns all directory entries for name.
func (treeFS *TreeFS) ReadDir(name string) ([]fs.DirEntry, error) {
	file, err := treeFS.Open(name)
	if err != nil {
		return nil, err
	}

	defer func() { _ = file.Close() }()

	readDirFile, ok := file.(fs.ReadDirFile)
	if !ok {
		return nil, treeFSPathError(treeFSOpReadDir, name, fs.ErrInvalid)
	}

	entries, err := readDirFile.ReadDir(-1)
	if err != nil {
		return nil, treeFSPathError(treeFSOpReadDir, name, err)
	}

	return entries, nil
}

// ReadFile reads the blob contents at name.
//
// Directories and gitlink entries are not readable through TreeFS.
func (treeFS *TreeFS) ReadFile(name string) ([]byte, error) {
	entry, err := treeFS.resolvePath(treeFSOpReadFile, name)
	if err != nil {
		return nil, err
	}

	if entry.isDir() {
		return nil, treeFSPathError(treeFSOpReadFile, name, ErrIsDirectory)
	}

	if entry.mode == mode.Gitlink {
		return nil, treeFSPathError(treeFSOpReadFile, name, ErrGitlinkNotFile)
	}

	reader, _, err := treeFS.fetcher.ExactBlobReader(entry.objectID)
	if err != nil {
		return nil, treeFSPathError(treeFSOpReadFile, name, err)
	}

	defer func() { _ = reader.Close() }()

	data, err := io.ReadAll(reader)
	if err != nil {
		return nil, treeFSPathError(treeFSOpReadFile, name, err)
	}

	return data, nil
}

// Stat returns synthetic file metadata for name.
//
// TreeFS metadata reflects Git tree entry mode and blob size where applicable.
// It does not represent filesystem stat metadata: ModTime is zero, ownership is
// unavailable, and Sys returns the underlying tree.Entry when one exists.
func (treeFS *TreeFS) Stat(name string) (fs.FileInfo, error) {
	entry, err := treeFS.resolvePath(treeFSOpStat, name)
	if err != nil {
		return nil, err
	}

	info, err := treeFS.statEntry(entry)
	if err != nil {
		return nil, treeFSPathError(treeFSOpStat, name, err)
	}

	return info, nil
}

// Sub returns a new TreeFS rooted at dir.
func (treeFS *TreeFS) Sub(dir string) (fs.FS, error) {
	entry, err := treeFS.resolvePath(treeFSOpSub, dir)
	if err != nil {
		return nil, err
	}

	treeID, err := entry.subtreeID()
	if err != nil {
		return nil, treeFSPathError(treeFSOpSub, dir, fs.ErrInvalid)
	}

	return &TreeFS{
		fetcher:   treeFS.fetcher,
		rootTree:  treeID,
		rootEntry: entry.treeEntry,
	}, nil
}

func (treeFS *TreeFS) resolvePath(op treeFSOp, name string) (treeEntryValue, error) {
	if !treeFSValidPath(name) {
		return treeEntryValue{}, treeFSPathError(op, name, fs.ErrInvalid)
	}

	if name == "." {
		return treeEntryValue{
			name:      ".",
			mode:      mode.Directory,
			treeID:    treeFS.rootTree,
			treeEntry: treeFS.rootEntry,
		}, nil
	}

	entry, err := treeFS.fetcher.Path(treeFS.rootTree, splitPath(name))
	if err != nil {
		return treeEntryValue{}, treeFS.pathResolveError(op, name, err)
	}

	return treeEntryValue{
		name:      string(entry.Name),
		mode:      entry.Mode,
		objectID:  entry.ID,
		treeEntry: &entry,
	}, nil
}

func (treeFS *TreeFS) pathResolveError(op treeFSOp, name string, err error) error {
	if _, ok := errors.AsType[*PathNotFoundError](err); ok {
		return treeFSPathError(op, name, fs.ErrNotExist)
	}

	if _, ok := errors.AsType[*PathNotTreeError](err); ok {
		return treeFSPathError(op, name, fs.ErrInvalid)
	}

	if errors.Is(err, ErrPathInvalid) {
		return treeFSPathError(op, name, fs.ErrInvalid)
	}

	return treeFSPathError(op, name, err)
}

func (treeFS *TreeFS) statEntry(entry treeEntryValue) (*treeFSInfo, error) {
	size := int64(0)

	if entry.mode == mode.Regular || entry.mode == mode.Executable || entry.mode == mode.Symlink {
		sz, err := entry.blobSize(treeFS.fetcher)
		if err != nil {
			return nil, err
		}

		size = int64(sz)
	}

	var sys any
	if entry.treeEntry != nil {
		sys = *entry.treeEntry
	}

	return &treeFSInfo{
		name:  entry.name,
		mode:  treeFSEntryMode(entry.mode),
		size:  size,
		sys:   sys,
		isDir: entry.isDir(),
	}, nil
}