"github.com/consensys/gnark-crypto/ecc"
"github.com/consensys/gnark/backend/groth16"
"github.com/consensys/gnark/frontend"
r1cs2 "github.com/consensys/gnark/frontend/cs/r1cs"
"github.com/consensys/gnark/std/hash/mimc"

// Hash the PreImage and store it in a variable
mimcHash.Write(circuit.PreImage)
computedHash := mimcHash.Sum()

// Assert that the computed hash equals the given public hash
api.AssertIsEqual(circuit.Hash, computedHash)
return nil

byteValue, _ := ioutil.ReadAll(file)

var inputs Inputs
err = json.Unmarshal(byteValue, &inputs)
if err != nil {
	fmt.Printf("Failed to parse the JSON file: %v\n", err)
	return
}

// Step 2: Convert PreImage and Hash from the JSON to big.Int
preImage := new(big.Int)
preImage.SetString(inputs.PreImage, 10) // Base 10 for parsing

hash := new(big.Int)
hash.SetString(inputs.Hash, 10) // Base 10 for parsing

// Step 3: Print PreImage and Hash

var circuit Circuit

// Step 4: Compile the circuit

// Step 6: Creating the witness (assignment) for the circuit
assignment := &Circuit{
	PreImage: frontend.Variable(preImage),
	Hash:     frontend.Variable(hash), // Directly pass the *big.Int hash as a Variable
}
fmt.Println("Expected Hash", assignment.PreImage)
start := time.Now()
r1cs, err := frontend.Compile(ecc.BN254.ScalarField(), r1cs2.NewBuilder, &circuit)
if err != nil {
	fmt.Printf("Compile failed: %v\n", err)
	return
}

// Step 5: Groth16 Setup
pk, vk, err := groth16.Setup(r1cs)
if err != nil {
	fmt.Printf("Setup failed: %v\n", err)
	return
}
// Step 7: Generate the witness for proof generation
witness, err := frontend.NewWitness(assignment, ecc.BN254.ScalarField())
if err != nil {
	fmt.Printf("Witness generation failed: %v\n", err)
	return
}

// Step 8: Proving the circuit

proof, err := groth16.Prove(r1cs, pk, witness)
if err != nil {
	fmt.Printf("Prove failed: %v\n", err)
	return
}
elapsed := time.Since(start)
fmt.Println("Time for Proof:", elapsed)
// Step 9: Creating the public witness for verification
publicAssignment := &Circuit{
	Hash: frontend.Variable(hash), // Directly pass the *big.Int hash for public verification
}

// Write the verification key to a file
vkF, err := os.Create(vkKeyFile)
if err != nil {
	fmt.Errorf("failed to create %s: %v", vkKeyFile, err)
}
defer vkF.Close()

_, err = vk.WriteTo(vkF)
if err != nil {
	fmt.Errorf("failed to write verification key: %v", err)
}

// Write the proof to a file
proofF, err := os.Create(proofFile)
if err != nil {
	fmt.Errorf("failed to create %s: %v", proofFile, err)
}
defer proofF.Close()

_, err = proof.WriteTo(proofF)
if err != nil {
	fmt.Errorf("failed to write proof: %v", err)
}

publicWitness, err := frontend.NewWitness(publicAssignment, ecc.BN254.ScalarField(), frontend.PublicOnly())
if err != nil {
	fmt.Printf("Public witness generation failed: %v\n", err)
	return
}

// Step 10: Verifying the proof
err = groth16.Verify(proof, vk, publicWitness)
if err != nil {
	fmt.Printf("Verification failed: %v\n", err)
	return
}
fmt.Printf("Verification succeeded\n")