package testkit

import (
	"encoding/hex"
	"errors"
	"fmt"
	"slices"
	"strings"

	"g.activething.com/go/DateKeys/profile"
	"g.activething.com/go/DateKeys/wordkey"
)

// WordKeyVectorFile is testdata/vectors/wordkey.json: the key of words of
// spec v0.11, §38.1. Normalize gives the words of a text; Check, what a
// writer does with them; Keys, the identity that the words derive for a
// capsule, with its recipient.
type WordKeyVectorFile struct {
	Spec        string          `json:"spec"`
	Description string          `json:"description"`
	Normalize   []WordNormalize `json:"normalize"`
	Check       []WordCheck     `json:"check"`
	Keys        []WordKeyVector `json:"keys"`
}

// WordNormalize is a text and its words, as wordkey.Normalize gives them.
type WordNormalize struct {
	Name  string   `json:"name"`
	Text  string   `json:"text"`
	Words []string `json:"words"`
}

// WordCheck is a text, its words and the result of wordkey.Check on them:
// ResultOK, or the text of its error.
type WordCheck struct {
	Name   string   `json:"name"`
	Text   string   `json:"text"`
	Words  []string `json:"words"`
	Result string   `json:"result"`
	Error  string   `json:"error,omitempty"`
}

// WordKeyVector is the identity of words for the capsule capsule_id of the
// round of the chain chain_hash: key, the raw X25519 identity, and
// recipient, its age1… recipient.
type WordKeyVector struct {
	Name      string   `json:"name"`
	Words     []string `json:"words"`
	ChainHash string   `json:"chain_hash"`
	Round     uint64   `json:"round"`
	CapsuleID string   `json:"capsule_id"`
	Key       string   `json:"key"`
	Recipient string   `json:"recipient"`
}

// cp is the string of the code point r: invisible code points are written
// by number in this file, never as themselves.
func cp(r rune) string { return string(r) }

// The spaces of spec §38.1, step 4.
var wordSpaces = []rune{
	0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x20, 0x85, 0xa0, 0x1680,
	0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200a,
	0x2028, 0x2029, 0x202f, 0x205f, 0x3000,
}

// The six words of the vector of spec §38.1.
const sixWords = "perro luna casa verde tren mar"

// WordKeyVectors computes testdata/vectors/wordkey.json, and fails if a
// vector does not get the words, the result or the key it is written for.
func WordKeyVectors() (WordKeyVectorFile, error) {
	f := WordKeyVectorFile{
		Spec: SpecVersion,
		Description: "The key of words (spec §38.1): the words of a text, after NFD, without U+0300 to U+036F, in simple lower case of Unicode 18.0.0 and split by the spaces of the list; " +
			"what a writer refuses; and the identity, PBKDF2-HMAC-SHA256 of 600000 rounds, for a chain hash, a round and a capsule_id. See testdata/README.md.",
	}
	var errs []error
	fail := func(format string, args ...any) { errs = append(errs, fmt.Errorf(format, args...)) }

	// Normalize.
	norm := []struct {
		name, text string
		want       []string
	}{
		{"the words of the vector of §38.1", sixWords, strings.Fields(sixWords)},
		{"accents, upper case and runs of spaces", "  Ábaco" + cp(0xa0) + "ÁRBOL" + cp(0x09) + "niño  ΣΑΣ  İ ", []string{"abaco", "arbol", "nino", "σασ", "i"}},
		{"«Ábaco ÁRBOL» of §38.1", "Ábaco ÁRBOL", []string{"abaco", "arbol"}},
		{"«abaco  arbol» of §38.1", "abaco  arbol", []string{"abaco", "arbol"}},
		{"«ábaco árbol» of §38.1", "ábaco árbol", []string{"abaco", "arbol"}},
		{"the accents written as combining marks", "a" + cp(0x301) + "baco a" + cp(0x301) + "rbol", []string{"abaco", "arbol"}},
		{"punctuation counts", "Perro, luna.", []string{"perro,", "luna."}},
		{"no text", "", []string{}},
		{"only spaces", " " + cp(0x09) + cp(0x3000) + " ", []string{}},
		{"the simple lower case of a final sigma", "ΟΔΟΣ", []string{"οδοσ"}},
		{"capital sharp s, lowered by its simple mapping", "STRAẞE", []string{"straße"}},
		{"a dotless i stays", "ı", []string{"ı"}},
		{"the angstrom sign, whose NFD is A and a ring", cp(0x212b), []string{"a"}},
		{"Hangul, decomposed into jamo", "한글", []string{"ᄒ" + "ᅡ" + "ᆫ" + "ᄀ" + "ᅳ" + "ᆯ"}},
		{"a combining mark outside U+0300 to U+036F stays", "a" + cp(0x20d7), []string{"a" + cp(0x20d7)}},
		{"fullwidth letters are not folded to ASCII", "ＡＢＣ", []string{"ａｂｃ"}},
		{"U+A7CB, lowered by Unicode 18.0.0 to U+0264", cp(0xa7cb), []string{cp(0x264)}},
		{"a zero width space is not a space", "a" + cp(0x200b) + "b", []string{"a" + cp(0x200b) + "b"}},
		{"U+180E is not a space", "a" + cp(0x180e) + "b", []string{"a" + cp(0x180e) + "b"}},
		{"a byte order mark is not a space", "a" + cp(0xfeff) + "b", []string{"a" + cp(0xfeff) + "b"}},
	}
	for _, s := range wordSpaces {
		norm = append(norm, struct {
			name, text string
			want       []string
		}{fmt.Sprintf("U+%04X is a space", s), "uno" + cp(s) + "dos", []string{"uno", "dos"}})
	}
	for _, c := range norm {
		got := wordkey.Normalize(c.text)
		if got == nil {
			got = []string{}
		}
		if !slices.Equal(got, c.want) {
			fail("normalize %q: %q, want %q", c.name, got, c.want)
		}
		f.Normalize = append(f.Normalize, WordNormalize{Name: c.name, Text: c.text, Words: got})
	}

	// Check.
	for _, c := range []struct{ name, text, want string }{
		{"six words", sixWords, ResultOK},
		{"six words with upper case and accents", "Perro LUNA casa verde trén mar", ResultOK},
		{"three words", "uno dos tres", "not 3"},
		{"only short words", "a b c d e f g h", "not 0"},
		{"one word six times", "perro perro perro perro perro perro", "not 1"},
		{"short words do not count", "de la casa al mar en tren verde", "not 4"},
		{"five words that count and a short one", "perro luna casa verde tren y", "not 5"},
		{"a word of three letters counts", "sol luna casa verde tren mar", ResultOK},
		{"a word of three letters that are not ASCII counts", "ñuñ luna casa verde tren mar", ResultOK},
		{"the same words in other case count once", "perro PERRO luna casa verde tren", "not 5"},
		{"a zero width space, which the writer refuses", sixWords + cp(0x200b), "invisible character U+200B"},
		{"a soft hyphen, ignorable", "per" + cp(0xad) + "ro luna casa verde tren mar", "invisible character U+00AD"},
		{"a variation selector, ignorable", sixWords + cp(0xfe0f), "invisible character U+FE0F"},
		{"a byte order mark", cp(0xfeff) + sixWords, "invisible character U+FEFF"},
		{"a control character", sixWords + cp(0x01), "control character U+0001"},
		{"a C1 control character", sixWords + cp(0x9f), "control character U+009F"},
		{"DEL", sixWords + cp(0x7f), "control character U+007F"},
		{"an unassigned code point", sixWords + cp(0x0378), "U+0378, unassigned"},
		{"a private use code point is assigned", sixWords + cp(0xe000), ResultOK},
		{"an emoji", "perro luna casa verde tren mar 🌍", ResultOK},
	} {
		words := wordkey.Normalize(c.text)
		if words == nil {
			words = []string{}
		}
		v := WordCheck{Name: c.name, Text: c.text, Words: words, Result: ResultOK}
		if err := wordkey.Check(words); err != nil {
			v.Result, v.Error = "error", err.Error()
		}
		switch {
		case c.want == ResultOK && v.Result != ResultOK:
			fail("check %q: %s, want ok", c.name, v.Error)
		case c.want != ResultOK && !strings.Contains(v.Error, c.want):
			fail("check %q: %q, want %q", c.name, v.Error, c.want)
		}
		f.Check = append(f.Check, v)
	}

	// Keys.
	quicknet := profile.QuicknetChainHash
	const mainnet = "8990e7a9aaed2ffed73dbd7092123d6f289930540d7651336225dc172e51b2ce"
	const id0 = "000102030405060708090a0b0c0d0e0f"
	for _, c := range []struct {
		name, text, chain string
		round             uint64
		capsuleID, want   string
	}{
		{"the vector of §38.1", sixWords, quicknet, 1000, id0, "fceec4d8ca8de86c85a1f26ed49f82a2b38431bd0ce36db995ae7dfd49b96e41"},
		{"the next round", sixWords, quicknet, 1001, id0, ""},
		{"another capsule_id", sixWords, quicknet, 1000, "000102030405060708090a0b0c0d0e0e", ""},
		{"another chain hash", sixWords, mainnet, 1000, id0, ""},
		{"round 2^53 - 1", sixWords, quicknet, 1<<53 - 1, id0, ""},
		{"words that are not ASCII", "Ábaco ÁRBOL niño ΣΑΣ ñandú straße", quicknet, 1000, "ffeeddccbbaa99887766554433221100", ""},
	} {
		chain, err := hex.DecodeString(c.chain)
		if err != nil {
			return f, err
		}
		capsuleID, err := hex.DecodeString(c.capsuleID)
		if err != nil {
			return f, err
		}
		words := wordkey.Normalize(c.text)
		raw, err := wordkey.Key(words, chain, c.round, capsuleID)
		if err != nil {
			return f, err
		}
		id, err := wordkey.Identity(words, chain, c.round, capsuleID)
		if err != nil {
			return f, err
		}
		key := hex.EncodeToString(raw)
		if c.want != "" && key != c.want {
			fail("key %q: %s, want %s", c.name, key, c.want)
		}
		for _, k := range f.Keys {
			if k.Key == key {
				fail("key %q: the same key as %q", c.name, k.Name)
			}
		}
		f.Keys = append(f.Keys, WordKeyVector{
			Name: c.name, Words: words, ChainHash: c.chain, Round: c.round, CapsuleID: c.capsuleID,
			Key: key, Recipient: id.Recipient().String(),
		})
	}
	return f, errors.Join(errs...)
}