package s5

import (
	"context"
	"encoding/hex"
	"errors"
	"io"
	"io/fs"
	"path"
	"slices"
	"sort"
	"strings"
	"time"

	s5libmetadata "git.lumeweb.com/LumeWeb/libs5-go/metadata"

	"git.lumeweb.com/LumeWeb/portal/protocols/s5"

	"git.lumeweb.com/LumeWeb/portal/metadata"

	"git.lumeweb.com/LumeWeb/portal/storage"

	"git.lumeweb.com/LumeWeb/libs5-go/encoding"
	"git.lumeweb.com/LumeWeb/libs5-go/types"
)

var _ io.ReadSeekCloser = (*S5File)(nil)
var _ fs.File = (*S5File)(nil)
var _ fs.ReadDirFile = (*S5File)(nil)
var _ fs.DirEntry = (*S5File)(nil)
var _ fs.FileInfo = (*S5FileInfo)(nil)

type S5File struct {
	reader   io.ReadCloser
	hash     []byte
	storage  storage.StorageService
	metadata metadata.MetadataService
	record   *metadata.UploadMetadata
	protocol *s5.S5Protocol
	cid      *encoding.CID
	typ      types.CIDType
	read     bool
	tus      *s5.TusHandler
	ctx      context.Context
	name     string
	root     []byte
	rootType types.CIDType
	rootCid  *encoding.CID
}

func (f *S5File) IsDir() bool {
	return f.typ == types.CIDTypeDirectory
}

func (f *S5File) Type() fs.FileMode {
	if f.typ == types.CIDTypeDirectory {
		return fs.ModeDir
	}

	return 0
}

func (f *S5File) Info() (fs.FileInfo, error) {
	return f.Stat()
}

type FileParams struct {
	Storage  storage.StorageService
	Metadata metadata.MetadataService
	Hash     []byte
	Type     types.CIDType
	Protocol *s5.S5Protocol
	Tus      *s5.TusHandler
	Name     string
	Root     []byte
	RootType types.CIDType
}

func NewFile(params FileParams) *S5File {
	return &S5File{
		storage:  params.Storage,
		metadata: params.Metadata,
		hash:     params.Hash,
		typ:      params.Type,
		protocol: params.Protocol,
		tus:      params.Tus,
		ctx:      context.Background(),
		name:     params.Name,
		root:     params.Root,
		rootType: params.RootType,
	}
}

func (f *S5File) Exists() bool {
	ctx := context.Background()
	exists, _ := f.tus.UploadExists(ctx, f.hash)

	if exists {
		return true
	}

	_, err := f.metadata.GetUpload(context.Background(), f.hash)

	if err != nil {
		return false
	}

	return true
}

func (f *S5File) Read(p []byte) (n int, err error) {
	err = f.init(0)
	if err != nil {
		return 0, err
	}
	f.read = true

	return f.reader.Read(p)
}

func (f *S5File) Seek(offset int64, whence int) (int64, error) {
	switch whence {
	case io.SeekStart:
		if !f.read && offset == 0 {
			return 0, nil
		}

		if f.reader != nil {
			err := f.reader.Close()
			if err != nil {
				return 0, err
			}
			f.reader = nil
		}
		err := f.init(offset)
		if err != nil {
			return 0, err
		}
	case io.SeekCurrent:
		return 0, errors.New("not supported")
	case io.SeekEnd:
		return int64(f.Size()), nil
	default:
		return 0, errors.New("invalid whence")
	}

	return 0, nil
}

func (f *S5File) Close() error {
	if f.reader != nil {
		r := f.reader
		f.reader = nil
		return r.Close()
	}

	return nil
}

func (f *S5File) init(offset int64) error {
	if f.reader == nil {
		reader, err := f.tus.GetUploadReader(f.ctx, f.hash, offset)

		if err == nil {
			f.reader = reader
			f.read = false
			return nil
		}

		reader, err = f.storage.DownloadObject(context.Background(), f.StorageProtocol(), f.hash, offset)
		if err != nil {
			return err
		}

		f.reader = reader
		f.read = false
	}

	return nil
}

func (f *S5File) Record() (*metadata.UploadMetadata, error) {
	if f.record == nil {
		exists, tusRecord := f.tus.UploadExists(context.Background(), f.hash)

		if exists {
			size, err := f.tus.GetUploadSize(context.Background(), f.hash)
			if err != nil {
				return nil, err
			}
			return &metadata.UploadMetadata{
				Hash:       f.hash,
				Size:       uint64(size),
				MimeType:   tusRecord.MimeType,
				Created:    tusRecord.CreatedAt,
				Protocol:   f.protocol.Name(),
				UploaderIP: tusRecord.UploaderIP,
				UserID:     tusRecord.UploaderID,
			}, nil
		}

		record, err := f.metadata.GetUpload(context.Background(), f.hash)

		if err != nil {
			return nil, errors.New("file does not exist")
		}

		f.record = &record
	}

	return f.record, nil
}

func (f *S5File) Hash() []byte {
	hashStr := f.HashString()

	if hashStr == "" {
		return nil
	}

	str, err := hex.DecodeString(hashStr)
	if err != nil {
		return nil
	}

	return str
}

func (f *S5File) HashString() string {
	record, err := f.Record()
	if err != nil {
		return ""
	}

	return hex.EncodeToString(record.Hash)
}

func (f *S5File) Name() string {
	if f.name != "" {
		return f.name
	}

	cid, _ := f.CID().ToString()

	return cid
}

func (f *S5File) Modtime() time.Time {
	record, err := f.Record()
	if err != nil {
		return time.Unix(0, 0)
	}

	return record.Created
}
func (f *S5File) Size() uint64 {
	record, err := f.Record()
	if err != nil {
		return 0
	}

	return record.Size
}
func (f *S5File) CID() *encoding.CID {
	if f.cid == nil {
		multihash := encoding.MultihashFromBytes(f.Hash(), types.HashTypeBlake3)

		typ := f.typ
		if typ == 0 {
			typ = types.CIDTypeRaw
		}

		cid := encoding.NewCID(typ, *multihash, f.Size())
		f.cid = cid
	}
	return f.cid
}

func (f *S5File) RootCID() *encoding.CID {
	if f.rootCid == nil {
		if f.root == nil {
			return nil
		}
		multihash := encoding.MultihashFromBytes(f.root, types.HashTypeBlake3)
		typ := f.rootType
		if typ == 0 {
			typ = types.CIDTypeRaw
		}

		cid := encoding.NewCID(typ, *multihash, f.Size())
		f.rootCid = cid

	}

	return f.rootCid
}

func (f *S5File) Mime() string {
	record, err := f.Record()
	if err != nil {
		return ""
	}

	return record.MimeType
}

func (f *S5File) StorageProtocol() storage.StorageProtocol {
	return s5.GetStorageProtocol(f.protocol)
}

func (f *S5File) Proof() ([]byte, error) {
	object, err := f.storage.DownloadObjectProof(context.Background(), f.StorageProtocol(), f.hash)

	if err != nil {
		return nil, err
	}

	proof, err := io.ReadAll(object)
	if err != nil {
		return nil, err
	}

	err = object.Close()
	if err != nil {
		return nil, err
	}

	return proof, nil
}
func (f *S5File) Manifest() (s5libmetadata.Metadata, error) {
	cid := f.RootCID()

	if cid == nil {
		cid = f.CID()
	}

	if f.Exists() {
		data, err := io.ReadAll(f)
		if err != nil {
			return nil, err
		}

		_, err = f.Seek(0, io.SeekStart)
		if err != nil {
			return nil, err
		}

		md, err := f.protocol.Node().Services().Storage().ParseMetadata(data, cid)
		if err != nil {
			return nil, err
		}

		return md, nil
	}

	meta, err := f.protocol.Node().Services().Storage().GetMetadataByCID(cid)
	if err != nil {
		return nil, err
	}

	return meta, nil
}

func (f *S5File) Stat() (fs.FileInfo, error) {
	return newS5FileInfo(f), nil
}

type S5FileInfo struct {
	file *S5File
}

func (s S5FileInfo) Name() string {
	return s.file.Name()
}

func (s S5FileInfo) Size() int64 {
	return int64(s.file.Size())
}

func (s S5FileInfo) Mode() fs.FileMode {
	return 0
}

func (s S5FileInfo) ModTime() time.Time {
	return s.file.Modtime()
}

func (s S5FileInfo) IsDir() bool {
	if s.file.name == "." {
		return true
	}

	manifest, err := s.file.Manifest()
	if err == nil && s.file.root != nil {
		webApp, ok := manifest.(*s5libmetadata.WebAppMetadata)
		if ok {
			if slices.Contains(webApp.TryFiles, path.Base(s.file.name)) {
				return true
			}
		}
	}

	return s.file.typ == types.CIDTypeDirectory
}

func (s S5FileInfo) Sys() any {
	return nil
}

func (f *S5File) ReadDir(n int) ([]fs.DirEntry, error) {
	manifest, err := f.Manifest()
	if err != nil {
		return nil, err
	}

	switch f.CID().Type {
	case types.CIDTypeDirectory:
		dir, ok := manifest.(*s5libmetadata.DirectoryMetadata)
		if !ok {
			return nil, errors.New("manifest is not a directory")
		}

		var entries []fs.DirEntry

		for _, file := range dir.Files.Items() {
			entries = append(entries, NewFile(FileParams{
				Storage:  f.storage,
				Metadata: f.metadata,
				Hash:     file.File.CID().Hash.HashBytes(),
				Type:     file.File.CID().Type,
				Tus:      f.tus,
				Name:     file.Name,
			}))
		}

		for _, subDir := range dir.Directories.Items() {
			cid, err := resolveDirCid(subDir, f.protocol.Node())
			if err != nil {
				return nil, err
			}
			entries = append(entries, NewFile(FileParams{
				Storage:  f.storage,
				Metadata: f.metadata,
				Hash:     cid.Hash.HashBytes(),
				Type:     cid.Type,
				Name:     subDir.Name,
			}))
		}

		return entries, nil

	case types.CIDTypeMetadataWebapp:
		webApp, ok := manifest.(*s5libmetadata.WebAppMetadata)
		if !ok {
			return nil, errors.New("manifest is not a web app")
		}

		var entries []fs.DirEntry
		dirMap := make(map[string]bool)

		webApp.Paths.Keys()

		for _, path := range webApp.Paths.Keys() {
			pathSegments := strings.Split(path, "/")

			// Check if the path is an immediate child (either a file or a direct subdirectory)
			if len(pathSegments) == 1 {
				// It's a file directly within `dirPath`
				entries = append(entries, newWebAppEntry(pathSegments[0], false))
			} else if len(pathSegments) > 1 {
				// It's a subdirectory, but ensure to add each unique subdirectory only once
				subDirName := pathSegments[0] // The immediate subdirectory name
				if _, exists := dirMap[subDirName]; !exists {
					entries = append(entries, newWebAppEntry(subDirName, true))
					dirMap[subDirName] = true
				}
			}
		}

		sort.Slice(entries, func(i, j int) bool {
			return entries[i].Name() < entries[j].Name()
		})

		return entries, nil
	}

	return nil, errors.New("unsupported CID type")
}

func newS5FileInfo(file *S5File) *S5FileInfo {
	return &S5FileInfo{
		file: file,
	}
}

type webAppEntry struct {
	name  string
	isDir bool
}

func newWebAppEntry(name string, isDir bool) *webAppEntry {
	return &webAppEntry{name: name, isDir: isDir}
}

func (d *webAppEntry) Name() string {
	return d.name
}

func (d *webAppEntry) IsDir() bool {
	return d.isDir
}

func (d *webAppEntry) Type() fs.FileMode {
	if d.isDir {
		return fs.ModeDir
	}

	return 0
}

func (d *webAppEntry) Info() (fs.FileInfo, error) {
	return &webAppFileInfo{name: d.name, isDir: true}, nil
}

type webAppFileInfo struct {
	name  string
	isDir bool
}

func (fi *webAppFileInfo) Name() string { return fi.name }
func (fi *webAppFileInfo) Size() int64  { return 0 }
func (fi *webAppFileInfo) Mode() fs.FileMode {
	if fi.isDir {
		return fs.ModeDir
	}

	return 0
}
func (fi *webAppFileInfo) ModTime() time.Time {
	return time.Time{}
}
func (fi *webAppFileInfo) IsDir() bool {
	return fi.isDir
}
func (fi *webAppFileInfo) Sys() interface{} {
	return nil
}