package pb

import (
	"testing"

	blseth "github.com/herumi/bls-eth-go-binary/bls"
	"github.com/stretchr/testify/assert"

	"gitlab.33.cn/link33/sidecar/pkg/crypto/bls"
)

func TestSign(t *testing.T) {
	assert.Nil(t, blseth.Init(blseth.BLS12_381), "bls init")
	ibtpx := &IBTPX{
		Ibtp: &IBTP{
			From:      "",
			To:        "",
			Nonce:     100,
			Type:      0,
			Timestamp: 0,
			Proof:     nil,
			Payload:   nil,
			Group:     nil,
			Version:   "",
			Extra:     []byte("TestSign"),
		},
		Mode:           "direct",
		RouteSign:      nil,
		RouteMethod:    "single",
		RouteMethodArg: nil,
		IsValid:        false,
		Count:          0,
	}
	assert.NotNil(t, ibtpx)

	pk, err := bls.GenerateKeyPair(bls.BlsEth)
	assert.Nil(t, err)
	assert.NotNil(t, pk)
	p, ok := pk.(*bls.PrivateKey)
	assert.True(t, ok, "privateKey error")
	assert.NotNil(t, p)
	assert.False(t, testVerify(p, ibtpx))
	assert.Nil(t, testSign(p, ibtpx))
	assert.True(t, testVerify(p, ibtpx))
	t.Log(ibtpx.RouteSign[0])

	// create other private key
	otherPrivateKey, err := bls.GenerateKeyPair(bls.BlsEth)
	assert.Nil(t, err)
	assert.NotNil(t, otherPrivateKey)
	op, ok := otherPrivateKey.(*bls.PrivateKey)
	assert.True(t, ok, "other privateKey error")
	assert.NotNil(t, op)
	assert.False(t, testVerify(op, ibtpx))
	assert.Nil(t, testSign(op, ibtpx))

	t.Log(ibtpx.RouteSign[0])
	assert.True(t, testVerify(op, ibtpx))

	assert.True(t, testAggVerify(ibtpx))
	ibtpx.RouteSign[1], ibtpx.RouteSign[2] = ibtpx.RouteSign[2], ibtpx.RouteSign[1]
	assert.True(t, testAggVerify(ibtpx))

	ibtpx.RouteSign[1] = "test"
	assert.False(t, testAggVerify(ibtpx))
}

func testSign(p *bls.PrivateKey, ibtpx *IBTPX) error {
	sign := p.SignByte(ibtpx.FrontPart())
	if len(ibtpx.RouteSign) > 0 && ibtpx.RouteSign[0] != "" {
		aggSign := bls.Sign{}
		if err := aggSign.DeserializeHexStr(ibtpx.RouteSign[0]); err != nil {
			return err
		}
		aggSign.Add(sign)
		ibtpx.RouteSign[0] = aggSign.SerializeToHexStr()
	} else {
		if ibtpx.RouteSign == nil {
			ibtpx.RouteSign = make([]string, 1)
		}
		ibtpx.RouteSign[0] = sign.SerializeToHexStr()
	}
	// TODO append publicKey
	ibtpx.RouteSign = append(ibtpx.RouteSign, p.GetPublicKey().SerializeToHexStr())
	return nil
}

func testVerify(p *bls.PrivateKey, ibtpx *IBTPX) bool {
	pkStr := p.GetPublicKey().SerializeToHexStr()
	if len(ibtpx.RouteSign) > 0 {
		for _, val := range ibtpx.RouteSign[1:] {
			if val == pkStr {
				return true
			}
		}
	}
	return false
}

func testAggVerify(ibtpx *IBTPX) bool {
	aggSign := &bls.Sign{}
	if len(ibtpx.RouteSign) > 0 {
		err := aggSign.DeserializeHexStr(ibtpx.RouteSign[0])
		if err != nil {
			return false
		}
		pks := &blseth.PublicKey{}
		for _, val := range ibtpx.RouteSign[1:] {
			pub := &blseth.PublicKey{}
			_ = pub.DeserializeHexStr(val)
			pks.Add(pub)
		}
		return aggSign.VerifyByte(pks, ibtpx.FrontPart())
	} else {
		return false
	}
}

// 1、签名是我签的，防伪证明。
// 2、所有的各个不同人的签名又能聚合在一起。压缩签名。（线性压缩）
// 3、通过聚合签名（压缩签名），也能验证是我签过名。
// 4、签名身份被替换。无法做到抵赖（修改签名本身）。
// 5、私自追加签名。无法被感知（串改）。
// 6、选择最少的那个。
// 解决以上问题，就可以了。

// 简单经济模型：
// 1、发送者提供资金（起始点）；
// 2、路由者获得奖励（中间点）；
// 3、接收者作为结速点（中间点）；
// 4、中继链裁决方分配（裁决）。
// 裁决方案：奖励金额最大、路由节点最少、速度最快方案裁决。

// 不同私钥对各自公钥的证明可以聚合。
// 不同私钥对不同消息的证明可以聚合。
// 不同私钥对不同消息的证明可以聚合。
// 不同私钥对相同消息的证明可以聚合。
// 相同私钥对不同消息的证明可以聚合。

// 无证书聚合签名方案

// 不同私钥对各自公钥的证明可以聚合。
// 不同私钥对不同消息的证明可以聚合。
// 不同私钥对不同消息的证明可以聚合。
// 不同私钥对相同消息的证明可以聚合。
// 相同私钥对不同消息的证明可以聚合。

// 无证书聚合签名方案