use dep::std;
use dep::helpers;
use dep::helpers::hash;
use dep::helpers::structs;

#[recursive]
fn main(
  public_inputs_hash: pub Field, 
  public_inputs: structs::PublicInputs, 
  private_inputs: structs::PrivateInputs
) {

    let tx_hash: Field = hash::hash_tx(public_inputs);

    assert(tx_hash == public_inputs_hash);
    
    let mut sum_in: Field = public_inputs.deposit_amount;
    let mut sum_out: Field = public_inputs.withdrawals;
    
    for i in 0..16 {
    if (private_inputs.utxo_in[i].amount != helpers::ZERO_VALUE) {
            let owner = hash::hash([private_inputs.secrets[i]]);
            assert(owner == private_inputs.utxo_in[i].owner);

            assert(public_inputs.nullifier_hashes[i] == hash::hash([private_inputs.secrets[i], private_inputs.secrets[i]]));

            let commitment_in = hash::hash([private_inputs.utxo_in[i].owner, private_inputs.utxo_in[i].amount, private_inputs.utxo_in[i].asset_type]);

            if (public_inputs.commitment_in[i] == helpers::ZERO_VALUE) {

                let utxo_root = hash::compute_merkle_root(
                    commitment_in,
                    private_inputs.merkle_proofs[i].index_utxo,
                    private_inputs.merkle_proofs[i].path_utxo
                );

                let tx_root = hash::compute_merkle_root(
                    utxo_root,
                    private_inputs.merkle_proofs[i].index_tx,
                    private_inputs.merkle_proofs[i].path_tx
                );

                let leaf_batch = hash::hash([tx_root, private_inputs.oracle[i]]);

                assert(private_inputs.oracle[i] == helpers::ZERO_VALUE); 

                let leaf_historic = hash::hash([leaf_batch, private_inputs.old_root_proof[i]]);

                let historic_root = hash::compute_merkle_root(
                    leaf_historic, 
                    private_inputs.merkle_proofs[i].index_historic,
                    private_inputs.merkle_proofs[i].path_historic
                );
                assert(historic_root == public_inputs.current_root);

            } else {
                assert(commitment_in == public_inputs.commitment_in[i]);
            }

            let sum_in_old: Field = sum_in;
            sum_in += private_inputs.utxo_in[i].amount;
            if (sum_in_old != sum_in) {
                assert(sum_in_old.lt(sum_in));
            }
        
        }
        
    }

    for k in 0..16 {
        if (public_inputs.commitment_out[k] != ZERO_VALUE) {

            assert(private_inputs.utxo_out[k].amount.lt(sum_in + 1));
            
            let sum_out_old: Field = sum_out;
            sum_out += private_inputs.utxo_out[k].amount;
            if (sum_out_old != sum_out) {
                assert(sum_out_old.lt(sum_out));
            }

            let commitment_out_calc = hash::hash([private_inputs.utxo_out[k].owner, private_inputs.utxo_out[k].amount, private_inputs.utxo_out[k].asset_type]);
            assert(commitment_out_calc == public_inputs.commitment_out[k]);
        }
    }
    
    assert(sum_in == sum_out);
    
    let utxo_root_calc: Field = hash::hash_tree_four(public_inputs.commitment_out);
    assert(utxo_root_calc == public_inputs.utxo_root);

}