package secp256k1

import (
	"math/big"
	"testing"
)

func TestFieldAddition(t *testing.T) {
	a := NewFieldElementFromInt64(7)
	b := NewFieldElementFromInt64(5)
	result := a.Add(b)

	expected := NewFieldElementFromInt64(12)
	if !result.Equal(expected) {
		t.Errorf("7 + 5 = %s, want 12", result.String())
	}
}

func TestFieldSubtraction(t *testing.T) {
	a := NewFieldElementFromInt64(7)
	b := NewFieldElementFromInt64(5)
	result := a.Sub(b)

	expected := NewFieldElementFromInt64(2)
	if !result.Equal(expected) {
		t.Errorf("7 - 5 = %s, want 2", result.String())
	}
}

func TestFieldSubtractionWraps(t *testing.T) {
	// 5 - 7 should wrap around (mod P)
	a := NewFieldElementFromInt64(5)
	b := NewFieldElementFromInt64(7)
	result := a.Sub(b)

	// 5 - 7 mod P = P - 2
	expected := new(big.Int).Sub(P, big.NewInt(2))
	if result.value.Cmp(expected) != 0 {
		t.Errorf("5 - 7 mod P should be P-2, got %s", result.String())
	}
}

func TestFieldMultiplication(t *testing.T) {
	a := NewFieldElementFromInt64(7)
	b := NewFieldElementFromInt64(5)
	result := a.Mul(b)

	expected := NewFieldElementFromInt64(35)
	if !result.Equal(expected) {
		t.Errorf("7 * 5 = %s, want 35", result.String())
	}
}

func TestFieldDivision(t *testing.T) {
	a := NewFieldElementFromInt64(10)
	b := NewFieldElementFromInt64(5)
	result := a.Div(b)

	expected := NewFieldElementFromInt64(2)
	if !result.Equal(expected) {
		t.Errorf("10 / 5 = %s, want 2", result.String())
	}
}

func TestFieldInverse(t *testing.T) {
	a := NewFieldElementFromInt64(5)
	inv := a.Inverse()
	product := a.Mul(inv)

	one := NewFieldElementFromInt64(1)
	if !product.Equal(one) {
		t.Errorf("5 * inverse(5) = %s, want 1", product.String())
	}
}

func TestFieldInverseLargeNumber(t *testing.T) {
	// Test with a larger number
	a := NewFieldElementFromInt64(123456789)
	inv := a.Inverse()
	product := a.Mul(inv)

	one := NewFieldElementFromInt64(1)
	if !product.Equal(one) {
		t.Errorf("a * inverse(a) = %s, want 1", product.String())
	}
}

func TestFieldSquare(t *testing.T) {
	a := NewFieldElementFromInt64(7)
	result := a.Square()

	expected := NewFieldElementFromInt64(49)
	if !result.Equal(expected) {
		t.Errorf("7² = %s, want 49", result.String())
	}
}

func TestFieldIsZero(t *testing.T) {
	zero := NewFieldElementFromInt64(0)
	if !zero.IsZero() {
		t.Error("0 should be zero")
	}

	one := NewFieldElementFromInt64(1)
	if one.IsZero() {
		t.Error("1 should not be zero")
	}
}

func TestFieldModReduction(t *testing.T) {
	// Creating element with P should reduce to 0
	result := NewFieldElement(P)
	if !result.IsZero() {
		t.Errorf("P mod P = %s, want 0", result.String())
	}

	// P + 1 should reduce to 1
	pPlusOne := new(big.Int).Add(P, big.NewInt(1))
	result = NewFieldElement(pPlusOne)
	expected := NewFieldElementFromInt64(1)
	if !result.Equal(expected) {
		t.Errorf("(P+1) mod P = %s, want 1", result.String())
	}
}

func TestFieldClone(t *testing.T) {
	a := NewFieldElementFromInt64(42)
	b := a.Clone()

	if !a.Equal(b) {
		t.Error("clone should equal original")
	}

	// Modify original, clone should be unchanged
	a.value.SetInt64(100)
	if a.Equal(b) {
		t.Error("clone should be independent of original")
	}
}