package main

import (
    "context"
    "crypto/ecdsa"
    "encoding/hex"
    "fmt"
    "log"
    "math/big"
    "os"
    "strings"
    "time"

    "github.com/ethereum/go-ethereum"
    "github.com/ethereum/go-ethereum/accounts/abi"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/common/hexutil"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/rlp"
    lacnet "prueba.com/ethclient"
)

func main() {
    contractDeployed := os.Args[1]
    contractAddress := common.HexToAddress(contractDeployed)

    client, err := lacnet.Dial(“<PUT_YOUR_RPC_NODE_CONNECTION>”)
    if err != nil {
        log.Fatal(err)
    }

    privateKey, err := crypto.HexToECDSA("c87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3")
    if err != nil {
        log.Fatal(err)
    }

    publicKey := privateKey.Public()
    publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
    if !ok {
        log.Fatal("error casting public key to ECDSA")
    }

    fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
    nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
    if err != nil {
        log.Fatal(err)
    }

    // arguments
    addressArg, err := abi.NewType("address", "", nil)
    if err != nil {
        log.Fatal(err)
    }
    uint256Arg, err := abi.NewType("uint256", "", nil)
    if err != nil {
        log.Fatal(err)
    }
    // Encode LACChain parameters
    lacchainAddress := common.HexToAddress(“PUT_YOUR_NODEADDRESS“) //Change this by your nodeAddress /lacchain/data/nodeAddress
    lacchainExpiration := new(big.Int).SetInt64(time.Now().Add(time.Minute * time.Duration(20)).Unix())
    argumentsLAC := abi.Arguments{
        {Type: addressArg},
        {Type: uint256Arg},
    }
    valueLAC, err := argumentsLAC.Pack(
        lacchainAddress,
        lacchainExpiration,
    )
    if err != nil {
        log.Fatal(err)
    }

    value := big.NewInt(0)      // in wei (0 eth)
    gasLimit := uint64(1000000) // in units
    gasPrice := big.NewInt(0)   // in wei 0 gas price

    json := `[{"inputs": [{"internalType": "uint256","name": "num","type": "uint256"}],"name": "store","outputs": [],"stateMutability": "nonpayable","type": "function"}]`
    //  method := NewMethod("", "", Constructor, "nonpayable", false, false, []Argument{{"a", Uint256, false}, {"b", Uint256, false}}, nil)
    // Test from JSON
    abiContract, err := abi.JSON(strings.NewReader(json))
    if err != nil {
        log.Fatal(err)
    }

    packed, err := abiContract.Pack("store", big.NewInt(30))
    if err != nil {
        log.Fatal(err)
    }

    data, _ := hexutil.Decode("0x" + hex.EncodeToString(packed) + hex.EncodeToString(valueLAC)) //Adding to additional parameters nodeAddress + expiration
    tx := types.NewTx(&types.LegacyTx{
        Nonce:    nonce,
        To:       &contractAddress,
        Value:    value,
        Gas:      gasLimit,
        GasPrice: gasPrice,
        Data:     data,
    })

    signedTx, err := types.SignTx(tx, types.FrontierSigner{}, privateKey)
    if err != nil {
        log.Fatal(err)
    }

    rawTxBytes, err := signedTx.MarshalBinary()
    if err != nil {
        log.Fatal(err)
    }
    rawTxHex := hex.EncodeToString(rawTxBytes)

    fmt.Println(rawTxHex) // f86...772

    rawTxRLPBytes, err := hex.DecodeString(rawTxHex)

    txRLP := new(types.Transaction)
    rlp.DecodeBytes(rawTxRLPBytes, &txRLP)

    txHash, err := client.SendTransactionLacchain(context.Background(), txRLP)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("tx sent: 0x%s\n", hex.EncodeToString(txHash))

    time.Sleep(7 * time.Second)

    receipt, err := client.TransactionReceipt(context.Background(), common.BytesToHash(txHash))
    if err != nil {
        fmt.Printf("failed get transaction receipt")
    }

    fmt.Printf("Transaction status: %d\n", receipt.Status)

    input, _ := hexutil.Decode("0xb05784b8")
    msg := ethereum.CallMsg{To: &contractAddress, Data: input}

    result, err := client.CallContract(context.Background(), msg, receipt.BlockNumber)
    if err != nil {
        fmt.Println("failed get value from smart contract", err)
    }

    resultArgument := abi.Arguments{
        {Type: uint256Arg},
    }
    newValue, err := resultArgument.Unpack(
        result,
    )
    if err != nil {
        fmt.Println(err)
    }

    fmt.Printf("New value is:%s", newValue)
}