package models

import (
	"fmt"
	"sync"

	"github.com/MichaelMure/git-bug/cache"
	"github.com/MichaelMure/git-bug/entity"
	"github.com/MichaelMure/git-bug/identity"
	"github.com/MichaelMure/git-bug/util/lamport"
	"github.com/MichaelMure/git-bug/util/timestamp"
)

type IdentityWrapper interface {
	Id() entity.Id
	Name() string
	Email() (string, error)
	AvatarUrl() (string, error)
	Keys() ([]*identity.Key, error)
	ValidKeysAtTime(time lamport.Time) ([]*identity.Key, error)
	DisplayName() string
	IsProtected() (bool, error)
	LastModificationLamport() (lamport.Time, error)
	LastModification() (timestamp.Timestamp, error)
}

var _ IdentityWrapper = &LazyIdentity{}

type LazyIdentity struct {
	cache   *cache.RepoCache
	excerpt *cache.IdentityExcerpt

	mu sync.Mutex
	id *cache.IdentityCache
}

func NewLazyIdentity(cache *cache.RepoCache, excerpt *cache.IdentityExcerpt) *LazyIdentity {
	return &LazyIdentity{
		cache:   cache,
		excerpt: excerpt,
	}
}

func (li *LazyIdentity) load() (*cache.IdentityCache, error) {
	if li.id != nil {
		return li.id, nil
	}

	li.mu.Lock()
	defer li.mu.Unlock()

	id, err := li.cache.ResolveIdentity(li.excerpt.Id)
	if err != nil {
		return nil, fmt.Errorf("cache: missing identity %v", li.excerpt.Id)
	}
	li.id = id
	return id, nil
}

func (li *LazyIdentity) Id() entity.Id {
	return li.excerpt.Id
}

func (li *LazyIdentity) Name() string {
	return li.excerpt.Name
}

func (li *LazyIdentity) Email() (string, error) {
	id, err := li.load()
	if err != nil {
		return "", err
	}
	return id.Email(), nil
}

func (li *LazyIdentity) AvatarUrl() (string, error) {
	id, err := li.load()
	if err != nil {
		return "", err
	}
	return id.AvatarUrl(), nil
}

func (li *LazyIdentity) Keys() ([]*identity.Key, error) {
	id, err := li.load()
	if err != nil {
		return nil, err
	}
	return id.Keys(), nil
}

func (li *LazyIdentity) ValidKeysAtTime(time lamport.Time) ([]*identity.Key, error) {
	id, err := li.load()
	if err != nil {
		return nil, err
	}
	return id.ValidKeysAtTime(time), nil
}

func (li *LazyIdentity) DisplayName() string {
	return li.excerpt.DisplayName()
}

func (li *LazyIdentity) IsProtected() (bool, error) {
	id, err := li.load()
	if err != nil {
		return false, err
	}
	return id.IsProtected(), nil
}

func (li *LazyIdentity) LastModificationLamport() (lamport.Time, error) {
	id, err := li.load()
	if err != nil {
		return 0, err
	}
	return id.LastModificationLamport(), nil
}

func (li *LazyIdentity) LastModification() (timestamp.Timestamp, error) {
	id, err := li.load()
	if err != nil {
		return 0, err
	}
	return id.LastModification(), nil
}

var _ IdentityWrapper = &LoadedIdentity{}

type LoadedIdentity struct {
	identity.Interface
}

func NewLoadedIdentity(id identity.Interface) *LoadedIdentity {
	return &LoadedIdentity{Interface: id}
}

func (l LoadedIdentity) Email() (string, error) {
	return l.Interface.Email(), nil
}

func (l LoadedIdentity) AvatarUrl() (string, error) {
	return l.Interface.AvatarUrl(), nil
}

func (l LoadedIdentity) Keys() ([]*identity.Key, error) {
	return l.Interface.Keys(), nil
}

func (l LoadedIdentity) ValidKeysAtTime(time lamport.Time) ([]*identity.Key, error) {
	return l.Interface.ValidKeysAtTime(time), nil
}

func (l LoadedIdentity) IsProtected() (bool, error) {
	return l.Interface.IsProtected(), nil
}

func (l LoadedIdentity) LastModificationLamport() (lamport.Time, error) {
	return l.Interface.LastModificationLamport(), nil
}

func (l LoadedIdentity) LastModification() (timestamp.Timestamp, error) {
	return l.Interface.LastModification(), nil
}