package bleve

import (
	"encoding/json"
	"errors"
	"fmt"
	"iter"
	"slices"
	"strconv"
	"strings"
	"sync"
	"time"

	"fiatjaf.com/nostr"
	"fiatjaf.com/nostr/eventstore"
	"fiatjaf.com/nostr/nip27"
	"fiatjaf.com/nostr/nip73"
	"fiatjaf.com/nostr/sdk"
	bleve "github.com/blevesearch/bleve/v2"
	_ "github.com/blevesearch/bleve/v2/analysis/analyzer/simple"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/ar"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/cjk"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/da"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/de"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/en"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/es"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/fa"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/fi"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/fr"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/gl"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/hi"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/hr"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/hu"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/in"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/it"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/nl"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/no"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/pl"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/pt"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/ro"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/ru"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/sv"
	_ "github.com/blevesearch/bleve/v2/analysis/lang/tr"
	bleveMapping "github.com/blevesearch/bleve/v2/mapping"
	bleveQuery "github.com/blevesearch/bleve/v2/search/query"
	"github.com/pemistahl/lingua-go"
)

const (
	labelContentField    = "c"
	labelKindField       = "k"
	labelCreatedAtField  = "a"
	labelAuthorField     = "p"
	labelReferencesField = "r"
	labelExtrasField     = "x"
)

var SupportedLanguages = []lingua.Language{
	// each of these translates to a specific bleve analyzer
	// except for japanese-korean-chinese that all use the same "cjk" analyzer
	lingua.Arabic,
	lingua.Chinese,
	lingua.Croatian,
	lingua.Danish,
	lingua.Dutch,
	lingua.English,
	lingua.Finnish,
	lingua.French,
	lingua.German,
	lingua.Hindi,
	lingua.Hungarian,
	lingua.Italian,
	lingua.Japanese,
	lingua.Korean,
	lingua.Persian,
	lingua.Polish,
	lingua.Portuguese,
	lingua.Romanian,
	lingua.Russian,
	lingua.Spanish,
	lingua.Swedish,
	lingua.Turkish,
}

type BleveBackend struct {
	sync.Mutex
	Path          string
	RawEventStore eventstore.Store
	ReadOnly      bool
	OpenTimeout   time.Duration

	IndexableKinds []nostr.Kind

	Languages     []lingua.Language
	languageCodes []string

	index    bleve.Index
	detector lingua.LanguageDetector
}

func (b *BleveBackend) Init() error {
	if b.Path == "" {
		return fmt.Errorf("missing Path")
	}
	if b.RawEventStore == nil {
		return fmt.Errorf("missing RawEventStore")
	}
	if len(b.Languages) == 0 {
		return fmt.Errorf("missing Languages")
	}
	if len(b.IndexableKinds) == 0 {
		b.IndexableKinds = []nostr.Kind{0, 1, 6, 11, 16, 20, 21, 22, 24, 1111, 9802, 30023, 30818}
	}

	validLanguages := make([]lingua.Language, 0, len(b.Languages))
	b.languageCodes = make([]string, 0, len(b.Languages))
	for _, lang := range b.Languages {
		var code string

		switch lang {
		case lingua.Chinese, lingua.Korean, lingua.Japanese:
			code = "cjk"
		default:
			code = strings.ToLower(lang.IsoCode639_1().String())
		}

		if slices.Contains(b.languageCodes, code) {
			continue
		}

		validLanguages = append(validLanguages, lang)
		b.languageCodes = append(b.languageCodes, code)
	}
	b.Languages = validLanguages

	opts := map[string]any{
		"read_only": b.ReadOnly,
	}
	if b.OpenTimeout != 0 {
		opts["bolt_timeout"] = b.OpenTimeout.String()
	}

	index, err := bleve.OpenUsing(b.Path, opts)
	if err == bleve.ErrorIndexPathDoesNotExist {
		mapping := bleveMapping.NewIndexMapping()
		mapping.DefaultMapping.Dynamic = false
		doc := bleveMapping.NewDocumentStaticMapping()

		for _, code := range b.languageCodes {
			contentField := bleveMapping.NewTextFieldMapping()
			contentField.Analyzer = code
			contentField.Store = false
			contentField.IncludeTermVectors = false
			contentField.DocValues = false
			contentField.IncludeInAll = false
			doc.AddFieldMappingsAt(labelContentField+"_"+code, contentField)
		}

		extrasField := bleveMapping.NewTextFieldMapping()
		extrasField.Analyzer = "simple"
		extrasField.Store = false
		extrasField.IncludeTermVectors = false
		extrasField.DocValues = false
		extrasField.IncludeInAll = false
		doc.AddFieldMappingsAt(labelExtrasField, extrasField)

		referencesField := bleveMapping.NewKeywordFieldMapping()
		referencesField.DocValues = false
		referencesField.Store = false
		referencesField.IncludeTermVectors = false
		referencesField.IncludeInAll = false
		doc.AddFieldMappingsAt(labelReferencesField, referencesField)

		authorField := bleveMapping.NewKeywordFieldMapping()
		authorField.DocValues = false
		authorField.Store = false
		authorField.IncludeTermVectors = false
		doc.AddFieldMappingsAt(labelAuthorField, authorField)

		kindField := bleveMapping.NewKeywordFieldMapping()
		kindField.DocValues = false
		kindField.Store = false
		kindField.IncludeTermVectors = false
		kindField.IncludeInAll = false
		doc.AddFieldMappingsAt(labelKindField, kindField)

		timestampField := bleveMapping.NewDateTimeFieldMapping()
		timestampField.DocValues = false
		timestampField.Store = false
		timestampField.IncludeTermVectors = false
		timestampField.IncludeInAll = false
		doc.AddFieldMappingsAt(labelCreatedAtField, timestampField)

		mapping.AddDocumentMapping("_default", doc)

		index, err = bleve.New(b.Path, mapping)
		if err != nil {
			return fmt.Errorf("error creating index: %w", err)
		}
	} else if err != nil {
		return fmt.Errorf("error opening index: %w", err)
	}

	b.index = index
	b.detector = lingua.NewLanguageDetectorBuilder().
		FromLanguages(b.Languages...).
		Build()

	return nil
}

func (b *BleveBackend) Close() {
	if b != nil && b.index != nil {
		b.index.Close()
	}
}

func (b *BleveBackend) SaveEvent(event nostr.Event) error {
	if slices.Contains(b.IndexableKinds, event.Kind) {
		return b.indexEvent(event)
	}
	return nil
}

func (b *BleveBackend) DeleteEvent(id nostr.ID) error {
	if b != nil && b.index != nil {
		return b.index.Delete(id.Hex())
	}
	return nil
}

func (b *BleveBackend) indexEvent(evt nostr.Event) error {
	docID := evt.ID

	var references []string
	var extras string

	switch evt.Kind {
	case 6, 16:
		var innerEvt nostr.Event
		if err := json.Unmarshal([]byte(evt.Content), &innerEvt); err != nil || !innerEvt.VerifySignature() {
			return nil
		}
		evt = innerEvt
	case 0:
		var pm sdk.ProfileMetadata
		if err := json.Unmarshal([]byte(evt.Content), &pm); err == nil {
			evt.Content = pm.Name + "\n" + pm.DisplayName + "\n" + pm.About
			references = append(references, pm.NIP05)
		}
	}

	for _, tag := range evt.Tags {
		if len(tag) < 2 {
			continue
		}
		switch tag[0] {
		case "comment", "name", "title", "about", "description":
			evt.Content += "\n\n" + tag[1]
		case "e":
			if ptr, err := nostr.EventPointerFromTag(tag); err == nil {
				references = append(references, ptr.AsTagReference())
			}
		case "a":
			if ptr, err := nostr.EntityPointerFromTag(tag); err == nil {
				references = append(references, ptr.AsTagReference())
			}
		case "r":
			references = append(references, tag[1])
		}
	}

	doc := map[string]any{
		labelKindField:      strconv.Itoa(int(evt.Kind)),
		labelAuthorField:    evt.PubKey.Hex()[56:],
		labelCreatedAtField: evt.CreatedAt.Time(),
	}

	content := strings.Builder{}
	content.Grow(len(evt.Content))

	for block := range nip27.Parse(evt.Content) {
		if block.Pointer == nil {
			content.WriteString(strings.TrimSpace(block.Text))
		} else {
			references = append(references, block.Pointer.AsTagReference())
			if ep, ok := block.Pointer.(nip73.ExternalPointer); ok {
				extras += ep.Thing + " "
			}
		}
	}

	indexableContent := content.String()
	lang, ok := b.detector.DetectLanguageOf(indexableContent)
	if !ok {
		lang = lingua.English
	}

	var analyzerLangCode string
	switch lang {
	case lingua.Japanese, lingua.Chinese, lingua.Korean:
		analyzerLangCode = "cjk"
	default:
		analyzerLangCode = strings.ToLower(lang.IsoCode639_1().String())
	}
	doc[labelContentField+"_"+analyzerLangCode] = indexableContent

	doc[labelReferencesField] = references
	doc[labelExtrasField] = extras

	if err := b.index.Index(docID.Hex(), doc); err != nil {
		return fmt.Errorf("failed to index '%s' document: %w", docID.Hex(), err)
	}

	return nil
}

func (b *BleveBackend) CountEvents(filter nostr.Filter) (uint32, error) {
	if filter.String() == "{}" {
		count, err := b.index.DocCount()
		return uint32(count), err
	}

	return 0, errors.New("not supported")
}

func (b *BleveBackend) QueryEvents(filter nostr.Filter, maxLimit int) iter.Seq[nostr.Event] {
	return func(yield func(nostr.Event) bool) {
		if tlimit := filter.GetTheoreticalLimit(); tlimit == 0 {
			return
		} else if tlimit < maxLimit {
			maxLimit = tlimit
		}

		filter.Search = strings.TrimSpace(filter.Search)
		if len(filter.Search) < 2 {
			return
		}

		and := make([]bleveQuery.Query, 0, 3)

		searchC := strings.Builder{}
		searchC.Grow(len(filter.Search))

		for block := range nip27.Parse(filter.Search) {
			if block.Pointer != nil {
				genericRef := bleve.NewTermQuery(block.Pointer.AsTagReference())
				genericRef.SetField(labelReferencesField)
				genericRef.SetBoost(2)

				var ref bleveQuery.Query = genericRef
				if profile, ok := block.Pointer.(nostr.ProfilePointer); ok {
					authorQuery := bleve.NewTermQuery(profile.PublicKey.Hex()[56:])
					authorQuery.SetField(labelAuthorField)
					authorQuery.SetBoost(2)
					orRef := bleve.NewDisjunctionQuery()
					orRef.AddQuery(genericRef)
					orRef.AddQuery(authorQuery)
					ref = orRef
				} else if addr, ok := block.Pointer.(nostr.EntityPointer); ok {
					authorQuery := bleve.NewTermQuery(addr.PublicKey.Hex()[56:])
					authorQuery.SetField(labelAuthorField)
					authorQuery.SetBoost(2)
					orRef := bleve.NewDisjunctionQuery()
					orRef.AddQuery(genericRef)
					orRef.AddQuery(authorQuery)
					ref = orRef
				}
				and = append(and, ref)
			} else {
				searchC.WriteString(strings.TrimSpace(block.Text))
			}
		}

		searchContent := searchC.String()

		var exactMatches []string
		if len(searchContent) > 0 {
			contentQueries := make([]bleveQuery.Query, 0, len(b.Languages)+1)

			searchQ, exactMatches_, err := parse(searchContent, labelContentField+"_"+b.languageCodes[0])
			if err != nil {
				for _, code := range b.languageCodes {
					match := bleve.NewMatchQuery(searchContent)
					match.SetField(labelContentField + "_" + code)
					contentQueries = append(contentQueries, match)
				}
			} else {
				contentQueries = append(contentQueries, searchQ)
				for _, code := range b.languageCodes[1:] {
					searchQ, _, _ := parse(searchContent, labelContentField+"_"+code)
					contentQueries = append(contentQueries, searchQ)
				}
			}
			exactMatches = exactMatches_

			extrasQ := bleve.NewMatchQuery(searchContent)
			extrasQ.SetField(labelExtrasField)
			contentQueries = append(contentQueries, extrasQ)

			and = append(and, bleveQuery.NewDisjunctionQuery(contentQueries))
		}

		if len(filter.Kinds) > 0 {
			eitherKind := bleve.NewDisjunctionQuery()
			for _, kind := range filter.Kinds {
				kindQ := bleve.NewTermQuery(strconv.Itoa(int(kind)))
				kindQ.SetField(labelKindField)
				eitherKind.AddQuery(kindQ)
			}
			and = append(and, eitherKind)
		}

		if len(filter.Authors) > 0 {
			eitherPubkey := bleve.NewDisjunctionQuery()
			for _, pubkey := range filter.Authors {
				pubkeyQ := bleve.NewTermQuery(pubkey.Hex()[56:])
				pubkeyQ.SetField(labelAuthorField)
				eitherPubkey.AddQuery(pubkeyQ)
			}
			and = append(and, eitherPubkey)
		}

		if filter.Since != 0 || filter.Until != 0 {
			var min time.Time
			if filter.Since != 0 {
				min = filter.Since.Time()
			}
			var max time.Time
			if filter.Until != 0 {
				max = filter.Until.Time()
			} else {
				max = time.Now()
			}
			dateRangeQ := bleve.NewDateRangeQuery(min, max)
			dateRangeQ.SetField(labelCreatedAtField)
			and = append(and, dateRangeQ)
		}

		q := bleveQuery.NewConjunctionQuery(and)
		req := bleve.NewSearchRequest(q)
		req.Size = maxLimit
		req.From = 0
		req.Explain = true

		result, err := b.index.Search(req)
		if err != nil {
			return
		}

	resultHit:
		for _, hit := range result.Hits {
			id, err := nostr.IDFromHex(hit.ID)
			if err != nil {
				continue
			}
			for evt := range b.RawEventStore.QueryEvents(nostr.Filter{IDs: []nostr.ID{id}}, 1) {
				for _, exactMatch := range exactMatches {
					if !strings.Contains(strings.ToLower(evt.Content), exactMatch) {
						continue resultHit
					}
				}

				for f, v := range filter.Tags {
					if !evt.Tags.ContainsAny(f, v) {
						continue resultHit
					}
				}

				if !yield(evt) {
					return
				}
			}
		}
	}
}