package carddav

import (
	"context"
	"fmt"
	"log/slog"
	"net/http"
	"path"
	"strings"
	"time"

	vcard "github.com/emersion/go-vcard"
	"github.com/emersion/go-webdav"
	"github.com/emersion/go-webdav/carddav"
	"github.com/yourusername/caldav-server/internal/auth"
	"github.com/yourusername/caldav-server/internal/config"
	"github.com/yourusername/caldav-server/internal/db"
	"github.com/yourusername/caldav-server/internal/store"
)

// sharedNameSep separates the owner from the address book name in the
// synthetic name used for address books shared with another user (see
// caldav.sharedNameSep, kept identical for consistency).
const sharedNameSep = "~"

// Backend implements carddav.Backend using a filesystem store.
type Backend struct {
	cfg    *config.Config
	store  *store.Store
	dbase  *db.DB // may be nil if sharing is not configured
	logger *slog.Logger
}

// NewBackend creates a CardDAV backend. dbase may be nil, in which case
// address book sharing is disabled (only a user's own books are visible).
func NewBackend(cfg *config.Config, st *store.Store, dbase *db.DB, logger *slog.Logger) *Backend {
	return &Backend{cfg: cfg, store: st, dbase: dbase, logger: logger}
}

// NewHandler returns an http.Handler for the /card/ prefix.
func NewHandler(cfg *config.Config, st *store.Store, dbase *db.DB, logger *slog.Logger) http.Handler {
	b := NewBackend(cfg, st, dbase, logger)
	return &carddav.Handler{Backend: b}
}

// -------- carddav.Backend interface --------

func (b *Backend) CurrentUserPrincipal(ctx context.Context) (string, error) {
	if auth.FromContext(ctx) == nil {
		return "", webdav.NewHTTPError(http.StatusUnauthorized, fmt.Errorf("not authenticated"))
	}
	// Must resolve to a path served by this same handler (i.e. under
	// /card/) at exactly one path segment of depth — see cardPrincipalPath.
	return cardPrincipalPath(), nil
}

func (b *Backend) AddressBookHomeSetPath(ctx context.Context) (string, error) {
	if auth.FromContext(ctx) == nil {
		return "", webdav.NewHTTPError(http.StatusUnauthorized, fmt.Errorf("not authenticated"))
	}
	return cardHomePath(), nil
}

func (b *Backend) ListAddressBooks(ctx context.Context) ([]carddav.AddressBook, error) {
	p := auth.FromContext(ctx)
	if p == nil {
		return nil, webdav.NewHTTPError(http.StatusUnauthorized, fmt.Errorf("not authenticated"))
	}

	names, err := b.dbase.ListAddressBooks(p.Username)
	if err != nil {
		return nil, fmt.Errorf("listing address books: %w", err)
	}

	var books []carddav.AddressBook
	for _, name := range names {
		if err := b.store.EnsureCollection(p.Username, "col/addressbooks/"+name); err != nil {
			b.logger.Warn("ensuring address book directory", "book", name, "error", err)
			continue
		}
		books = append(books, b.bookMeta(p.Username, name, name))
	}

	// Also include extra books that exist on disk but aren't registered
	disk, _ := b.store.ListCollections(p.Username)
	configured := make(map[string]bool)
	for _, n := range names {
		configured["card-"+n] = true
	}
	for _, dir := range disk {
		if strings.HasPrefix(dir, "col/addressbooks/") && !configured[dir] {
			name := strings.TrimPrefix(dir, "col/addressbooks/")
			books = append(books, b.bookMeta(p.Username, name, name))
		}
	}

	// Include address books other users have shared with this one.
	if b.dbase != nil {
		shares, err := b.dbase.AddressBooksSharedWith(p.Username)
		if err != nil {
			b.logger.Warn("listing shared address books", "error", err)
		}
		for _, sh := range shares {
			if _, err := b.store.GetCollection(sh.Owner, "card-"+sh.AddressBookName); err != nil {
				continue // owner's address book no longer exists
			}
			localName := sharedBookName(sh.Owner, sh.AddressBookName)
			books = append(books, b.bookMeta(sh.Owner, sh.AddressBookName, localName))
		}
	}

	return books, nil
}

func (b *Backend) GetAddressBook(ctx context.Context, bookPath string) (*carddav.AddressBook, error) {
	requester, localName, err := b.parseBookPath(ctx, bookPath)
	if err != nil {
		return nil, err
	}
	owner, realName, _, err := b.resolveBook(requester, localName, false)
	if err != nil {
		return nil, err
	}
	if _, err := b.store.GetCollection(owner, "card-"+realName); err != nil {
		return nil, webdav.NewHTTPError(http.StatusNotFound, err)
	}
	book := b.bookMeta(owner, realName, localName)
	return &book, nil
}

func (b *Backend) GetAddressObject(ctx context.Context, objPath string, req *carddav.AddressDataRequest) (*carddav.AddressObject, error) {
	requester, localName, objID, err := b.parseObjPath(ctx, objPath)
	if err != nil {
		return nil, err
	}
	owner, realName, _, err := b.resolveBook(requester, localName, false)
	if err != nil {
		return nil, err
	}

	data, err := b.store.GetObject(owner, "card-"+realName, objID)
	if err != nil {
		return nil, webdav.NewHTTPError(http.StatusNotFound, err)
	}

	return b.decodeObject(objPath, data)
}

func (b *Backend) ListAddressObjects(ctx context.Context, bookPath string, req *carddav.AddressDataRequest) ([]carddav.AddressObject, error) {
	requester, localName, err := b.parseBookPath(ctx, bookPath)
	if err != nil {
		return nil, err
	}
	owner, realName, _, err := b.resolveBook(requester, localName, false)
	if err != nil {
		return nil, err
	}

	ids, err := b.store.ListObjects(owner, "card-"+realName)
	if err != nil {
		return nil, err
	}

	var objs []carddav.AddressObject
	for _, id := range ids {
		data, err := b.store.GetObject(owner, "card-"+realName, id)
		if err != nil {
			continue
		}
		obj, err := b.decodeObject(cardObjectPath(localName, id), data)
		if err != nil {
			b.logger.Warn("decoding vcard object", "id", id, "error", err)
			continue
		}
		objs = append(objs, *obj)
	}
	return objs, nil
}

func (b *Backend) QueryAddressObjects(ctx context.Context, bookPath string, query *carddav.AddressBookQuery) ([]carddav.AddressObject, error) {
	all, err := b.ListAddressObjects(ctx, bookPath, &query.DataRequest)
	if err != nil {
		return nil, err
	}
	return carddav.Filter(query, all)
}

func (b *Backend) CreateAddressBook(ctx context.Context, book *carddav.AddressBook) error {
	p := auth.FromContext(ctx)
	if p == nil {
		return webdav.NewHTTPError(http.StatusUnauthorized, fmt.Errorf("not authenticated"))
	}
	name := path.Base(strings.TrimSuffix(book.Path, "/"))
	if err := b.dbase.CreateAddressBook(p.Username, name); err != nil && err != db.ErrResourceExists {
		return fmt.Errorf("registering address book: %w", err)
	}
	return b.store.EnsureCollection(p.Username, "card-"+name)
}

func (b *Backend) DeleteAddressBook(ctx context.Context, bookPath string) error {
	requester, localName, err := b.parseBookPath(ctx, bookPath)
	if err != nil {
		return err
	}
	owner, realName, _, err := b.resolveBook(requester, localName, true)
	if err != nil {
		return err
	}
	if err := b.dbase.DeleteAddressBook(owner, realName); err != nil && err != db.ErrResourceNotFound {
		return fmt.Errorf("unregistering address book: %w", err)
	}
	return b.store.DeleteCollection(owner, "card-"+realName)
}

func (b *Backend) PutAddressObject(ctx context.Context, objPath string, card vcard.Card, opts *carddav.PutAddressObjectOptions) (*carddav.AddressObject, error) {
	requester, localName, objID, err := b.parseObjPath(ctx, objPath)
	if err != nil {
		return nil, err
	}
	owner, realName, _, err := b.resolveBook(requester, localName, true)
	if err != nil {
		return nil, err
	}

	var buf strings.Builder
	enc := vcard.NewEncoder(&buf)
	if err := enc.Encode(card); err != nil {
		return nil, fmt.Errorf("encoding vcard: %w", err)
	}

	data := []byte(buf.String())
	if err := b.store.PutObject(owner, "card-"+realName, objID, data); err != nil {
		return nil, fmt.Errorf("storing address object: %w", err)
	}

	return b.decodeObject(objPath, data)
}

func (b *Backend) DeleteAddressObject(ctx context.Context, objPath string) error {
	requester, localName, objID, err := b.parseObjPath(ctx, objPath)
	if err != nil {
		return err
	}
	owner, realName, _, err := b.resolveBook(requester, localName, true)
	if err != nil {
		return err
	}
	if err := b.store.DeleteObject(owner, "card-"+realName, objID); err != nil {
		return webdav.NewHTTPError(http.StatusNotFound, err)
	}
	return nil
}

// -------- helpers --------

// sharedBookName builds the synthetic local name a shared address book is
// exposed under to the user it was shared with.
func sharedBookName(owner, bookName string) string {
	return owner + sharedNameSep + bookName
}

// resolveBook maps a local address book name (as seen in a URL path by
// requester) to its real owner and on-disk name, checking permissions
// along the way. Mirrors caldav.Backend.resolveCalendar.
func (b *Backend) resolveBook(requester, localName string, requireWrite bool) (owner, realName string, perm db.Permission, err error) {
	if ownerName, bookName, ok := strings.Cut(localName, sharedNameSep); ok {
		if b.dbase == nil {
			return "", "", "", webdav.NewHTTPError(http.StatusNotFound, fmt.Errorf("sharing not enabled"))
		}
		share, err := b.dbase.AddressBookShareFor(ownerName, bookName, requester)
		if err != nil {
			return "", "", "", webdav.NewHTTPError(http.StatusForbidden, fmt.Errorf("address book not shared with you"))
		}
		if requireWrite && share.Permission != db.PermWrite {
			return "", "", "", webdav.NewHTTPError(http.StatusForbidden, fmt.Errorf("read-only share"))
		}
		return ownerName, bookName, share.Permission, nil
	}
	return requester, localName, db.PermWrite, nil
}

func (b *Backend) bookMeta(owner, realName, localName string) carddav.AddressBook {
	return carddav.AddressBook{
		Path:            cardHomePath() + localName + "/",
		Name:            localName,
		Description:     fmt.Sprintf("%s's %s address book", owner, realName),
		MaxResourceSize: 10 * 1024 * 1024,
	}
}

func (b *Backend) decodeObject(objPath string, data []byte) (*carddav.AddressObject, error) {
	dec := vcard.NewDecoder(strings.NewReader(string(data)))
	card, err := dec.Decode()
	if err != nil {
		return nil, fmt.Errorf("decoding vcard: %w", err)
	}

	etag := fmt.Sprintf(`"%x"`, hashBytes(data))

	return &carddav.AddressObject{
		Path:          objPath,
		ModTime:       time.Now(),
		ContentLength: int64(len(data)),
		ETag:          etag,
		Card:          card,
	}, nil
}

func (b *Backend) parseBookPath(ctx context.Context, bookPath string) (user, bookName string, err error) {
	p := auth.FromContext(ctx)
	if p == nil {
		return "", "", webdav.NewHTTPError(http.StatusUnauthorized, fmt.Errorf("not authenticated"))
	}
	user = p.Username
	parts := strings.Split(strings.Trim(bookPath, "/"), "/")
	// expected: card/home/<bookname>/
	if len(parts) < 3 {
		return "", "", webdav.NewHTTPError(http.StatusBadRequest, fmt.Errorf("invalid address book path"))
	}
	bookName = parts[2]
	return user, bookName, nil
}

func (b *Backend) parseObjPath(ctx context.Context, objPath string) (user, bookName, objID string, err error) {
	p := auth.FromContext(ctx)
	if p == nil {
		return "", "", "", webdav.NewHTTPError(http.StatusUnauthorized, fmt.Errorf("not authenticated"))
	}
	user = p.Username
	parts := strings.Split(strings.Trim(objPath, "/"), "/")
	// expected: card/home/<bookname>/<objid>
	if len(parts) < 4 {
		return "", "", "", webdav.NewHTTPError(http.StatusBadRequest, fmt.Errorf("invalid object path"))
	}
	bookName = parts[2]
	objID = path.Base(objPath)
	return user, bookName, objID, nil
}

// cardPrincipalPath, cardHomePath, and cardObjectPath are the same for
// every user: authorization is resolved from the Basic Auth identity, not
// from the URL, so no username segment is needed in the path.
//
// The fixed "home" segment (in place of a username) is required, not
// cosmetic: go-webdav's carddav server classifies a request purely by how
// many path segments it has relative to the handler's mount point — 1
// segment is treated as the principal, 2 as the addressbook-home-set, 3 as
// an address book, 4 as an address object. Removing that segment entirely
// would make the home-set and address-book paths misclassified as
// principal/home-set respectively, breaking discovery (empty PROPFIND
// responses).
func cardPrincipalPath() string {
	return "/card/"
}

func cardHomePath() string {
	return "/card/home/"
}

func cardObjectPath(bookName, objID string) string {
	return fmt.Sprintf("/card/home/%s/%s", bookName, objID)
}

func hashBytes(data []byte) uint64 {
	var h uint64 = 14695981039346656037
	for _, b := range data {
		h ^= uint64(b)
		h *= 1099511628211
	}
	return h
}