package jwt

import (
	"encoding/base64"

	. "gopkg.in/check.v1"
)

type JOSESuite struct{}

var _ = Suite(&JOSESuite{})

func (s *JOSESuite) TestCheckForDataEncoding(c *C) {
	data := map[string]string{
		`"alg":"none"}`: `json: .*`,
		`{alg:"none"}`:  `invalid character '.' looking for beginning of object key string`,
		`{"alg":1234}`:  `json: cannot unmarshal float64 into Go value of type string`,
	}

	for dec, errMatches := range data {
		encoded := make([]byte, Base64EncodedBufferLen(len(dec)))
		base64.URLEncoding.Encode(encoded, []byte(dec))

		j, err := DecodeJOSE(encoded)
		c.Check(j, IsNil)
		c.Check(err, ErrorMatches, errMatches)
	}

}

func (s *JOSESuite) TestHandleDuplicateField(c *C) {

	decoded := `{"alg":"foo","alg":"none"}`
	encoded := make([]byte, Base64EncodedBufferLen(len(decoded)))
	base64.URLEncoding.Encode(encoded, []byte(decoded))
	j, err := DecodeJOSE(encoded)
	c.Assert(j, NotNil)
	c.Assert(err, IsNil)
	c.Assert(j.Algorithm, Equals, "none")

}

func (s *JOSESuite) TestHeaderValidation(c *C) {

	data := map[string]string{
		`{"alg":""}`: `jwt: missing 'alg' header`,
		`{}`:         `jwt: missing 'alg' header`,
	}

	for dec, errMatches := range data {
		encoded := make([]byte, Base64EncodedBufferLen(len(dec)))
		base64.URLEncoding.Encode(encoded, []byte(dec))
		j, err := DecodeJOSE(encoded)
		c.Check(j, NotNil)
		c.Check(err, IsNil)
		c.Check(j.Validate(), ErrorMatches, errMatches)
	}

}

func (s *JOSESuite) TestHandlesPrivateHeaders(c *C) {
	data := []map[string]interface{}{
		map[string]interface{}{
			"foo":  true,
			"bar":  12.34,
			"baz":  float64(456), //default of json is to parse float64
			"blah": "omg",
		},
	}

	for _, headers := range data {
		j := &JOSE{
			Algorithm:         "none",
			AdditionalHeaders: make(map[string]interface{}),
		}
		for n, v := range headers {
			j.AdditionalHeaders[n] = v
		}
		enc, err := j.EncodeBase64()
		if c.Check(err, IsNil) == false {
			continue
		}

		res, err := DecodeJOSE(enc)
		c.Check(err, IsNil)
		c.Assert(res, DeepEquals, j)
	}
}

func (s *JOSESuite) TestEncodingIsCompact(c *C) {
	j := &JOSE{
		Algorithm: "none",
		Critical:  []string{"exp", "foo"},
	}
	// it does not print empty fields.
	data, err := j.EncodeJSON()
	c.Check(err, IsNil)
	c.Check(string(data), Equals, `{"alg":"none","crit":["exp","foo"]}`)

	b64, err := j.EncodeBase64()
	c.Check(err, IsNil)
	c.Check(len(b64), Equals, 47)
}