package document

import (
	"testing"
)

var signedData = []struct {
	text string
	ok   bool
	hash string
	body string
	sig  string
}{
	{
		`-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

body
-----BEGIN PGP SIGNATURE-----
sig
`, true, "SHA1", "body", "-----BEGIN PGP SIGNATURE-----\nsig\n"},
	{
		`-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Hash: SHA256

- body  
-----BEGIN PGP SIGNATURE-----
sig
`, false, "", "body", "-----BEGIN PGP SIGNATURE-----\nsig\n"},
}

func TestSigned(t *testing.T) {
	for _, x := range signedData {
		c, err := ParseSigned([]byte(x.text))
		if err != nil {
			t.Errorf("parsing %q failed: %s\n", x.text, err)
			continue
		}
		if string(c.Body) != x.body {
			t.Errorf("expected: %q, got %q\n", x.body, c.Body)
		}
		if string(c.Signature) != x.sig {
			t.Errorf("expected: %q, got %q\n", x.sig, c.Signature)
		}
	}
	for _, x := range signedData {
		if !x.ok {
			continue
		}
		c := &Signed{x.hash, []byte(x.body), []byte(x.sig)}
		s, err := FormatSigned(c)
		if err != nil {
			t.Errorf("formating %#v failed: %s\n", c, err)
			continue
		}
		if string(s) != x.text {
			t.Errorf("expected: %q, got %q\n", x.text, s)
		}
	}
}

var docData = []struct {
	text string
	ok   bool
	t    string
	k    []string
	v    []string
}{
	{
		`Content-Type: text/vnd.epoint.draft; charset=utf-8

K1: v1
K2-Foo: v 2
K3: v 3
`, true, "Draft", []string{"K1", "K2-Foo", "K3"}, []string{"v1", "v 2", "v 3"}},
	{
		`Content-Type: text/vnd.epoint.debit; charset=utf-8

K1:  v1
K2-Foo: v 2
K3: v 3
`, true, "DebitCert", []string{"K1", "K2-Foo", "K3"}, []string{" v1", "v 2", "v 3"}},
	{
		`Content-Type: text/vnd.epoint.credit; charset=utf-8

K1: v1
K2-Foo: v 2
K3: v
 3
`, false, "CreditCert", []string{"K1", "K2-Foo", "K3"}, []string{"v1", "v 2", "v 3"}},
}

func TestDocument(t *testing.T) {
	for _, x := range docData {
		doc, err := ParseDocument([]byte(x.text))
		if err != nil {
			t.Errorf("parsing %q failed: %s\n", x.text, err)
			continue
		}
		if string(doc.Type) != x.t {
			t.Errorf("expected: %q, got %q\n", x.t, doc.Type)
		}
		if len(doc.Fields) != len(x.k) {
			t.Errorf("expected: %d fields, got %d\n", len(x.k), len(doc.Fields))
		}
		for i, k := range x.k {
			if doc.Fields[k] != x.v[i] {
				t.Errorf("value of %s expected to be %s, got %s\n", k, x.v[i], doc.Fields[k])
			}
		}
	}
	for _, x := range docData {
		if !x.ok {
			continue
		}
		doc := new(Document)
		doc.Type = x.t
		doc.Fields = make(map[string]string)
		doc.Order = x.k
		for i, k := range x.k {
			doc.Fields[k] = x.v[i]
		}
		s, err := FormatDocument(doc)
		if err != nil {
			t.Errorf("formating %#v failed: %s\n", doc, err)
			continue
		}
		if string(s) != x.text {
			t.Errorf("expected: %q, got %q\n", x.text, s)
		}
	}
}

const draftBody = `Content-Type: text/vnd.epoint.draft; charset=utf-8

Drawer: 000000000000000000000000000000000000000A
Beneficiary: 000000000000000000000000000000000000000B
Amount: 1
Denomination: half euro
Issuer: 000000000000000000000000000000000000000D
Authorized-By: 000000000000000000000000000000000000000C
Maturity-Date: 2011-11-13T12:20:35Z
Expiry-Date: 2011-12-27T09:18:46Z
Nonce: 42
Notes: some notes
`

func TestDraft(t *testing.T) {
	doc, err := ParseDocument([]byte(draftBody))
	if err != nil {
		t.Errorf("ParseDocument failed: %s\n", err)
		return
	}
	iv, err := ParseStruct(doc)
	if err != nil {
		t.Errorf("ParseStruct %v failed: %s\n", doc, err)
		return
	}
	d, ok := iv.(*Draft)
	if !ok {
		t.Errorf("expected *Draft got %#v\n", iv)
		return
	}
	doc, err = FormatStruct(d)
	if err != nil {
		t.Errorf("format %v draft failed: %s\n", d, err)
		return
	}
	s, err := FormatDocument(doc)
	if err != nil {
		t.Errorf("format %v doc failed: %s\n", doc, err)
		return
	}
	if string(s) != draftBody {
		t.Errorf("parsed %#v\nexpected: %s\ngot: %s\n", d, draftBody, s)
	}
}

const debitBody = `Content-Type: text/vnd.epoint.debit; charset=utf-8

Holder: 0000000000000000000000000000000000000009
Serial: 13
Balance: 23
Denomination: half euro
Issuer: 000000000000000000000000000000000000000B
Date: 2011-11-13T12:20:35Z
Authorized-By: 000000000000000000000000000000000000000A
Notes: -
Last-Debit-Serial: 0
Last-Credit-Serial: 12
Last-Cert: 000000000000000000000000000000000000000C
References: 000000000000000000000000000000000000000C
 000000000000000000000000000000000000000F
Difference: 1
Draft: 000000000000000000000000000000000000000D
Beneficiary: 000000000000000000000000000000000000000E
`

func TestCert(t *testing.T) {
	doc, err := ParseDocument([]byte(debitBody))
	if err != nil {
		t.Errorf("ParseDocument failed: %s\n", err)
		return
	}
	iv, err := ParseStruct(doc)
	if err != nil {
		t.Errorf("ParseStruct %v failed: %s\n", doc, err)
		return
	}
	d, ok := iv.(*DebitCert)
	if !ok {
		t.Errorf("expected *DebitCert got %#v\n", iv)
		return
	}
	doc, err = FormatStruct(d)
	if err != nil {
		t.Errorf("format %v draft failed: %s\n", d, err)
		return
	}
	s, err := FormatDocument(doc)
	if err != nil {
		t.Errorf("format %v doc failed: %s\n", doc, err)
		return
	}
	if string(s) != debitBody {
		t.Errorf("parsed %#v\nexpected: %s\ngot: %s\n", d, debitBody, s)
	}
}