enum MenuStatus {activated, deactivated}
enum OrderStatus {ordered, approved, denied}
enum RewardPolicyStatus {activated, deactivated}

struct Menu {
    string name;
    uint32 price;
    uint256 reward; // digit: peb
    MenuStatus status;
}

struct Order {
    address payable customer;
    string content;
    uint32 price;
    OrderStatus status;
}

event OrderReciept(
    uint32 indexed _id,
    address indexed _from,
    string _paymentTxId,
    string _content,
    uint32 _price
);

enum Status {activated, deactivated}
struct Store {
    string name;
    string locationX;
    string locationY;
    address storeOwner;
    address storeContract;
    Status status;
}

// DeployStoreContract handles Store Contract deploying requests with the given store name and the owner address.
func DeployStoreContract(c *gin.Context) {
	url := "https://wallet-api.klaytnapi.com/v2/tx/fd/contract/deploy"
	params := struct {
		Name string `form:"name" json:"name"`
		Owner string `form:"owner" json:"owner"`
	}{}

	// Step 1. Get user inputs from the request
	if err := c.ShouldBindJSON(&params); err != nil {
		c.String(-1, "invalid input data" + err.Error())
		return
	}

	// Step 2. Prepare field values of contract deploy transaction.
	// STORE_CONTRACT_ABI and STORE_CONTRACT_CODE are generated from the solidity code of Store Contract.
	_abi , err := abi.JSON(bytes.NewBufferString(STORE_CONTRACT_ABI))
	if err != nil {
		c.String(-1, err.Error())
		return
	}

    // Pack function convert user inputs to the rlp-encoded constructor parameter.
	inputParam, err := _abi.Constructor.Inputs.Pack(params.Name, common.HexToAddress(params.Owner))
	if err != nil {
		c.String(-1, err.Error())
		return
	}

    // input format of the KAS API, /v2/tx/fd/contract/deploy
	bodyData, err := json.Marshal(&kasDeployTxFD{
		From: KAS_ACCOUNT,
		Value: "0x0",
		GasLimit: 8000000,
		Input: STORE_CONTRACT_CODE + Encode(inputParam),
		Submit: true,
	})
	if err != nil {
		c.String(-1, err.Error())
		return
	}

	// Step 3. Call a KAS API with parameters and HTTP headers.
	// "Authorization" header should be set with your KAS API Key (e.g., "Basic xxxx...") .
	// "x-krn" header should indicate your KAS Wallet resource (e.g., "krn:1001:wallet:80:account:default").
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(bodyData))
	if err != nil {
		c.String(-1, err.Error())
		return
	}
	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("Authorization", KAS_API_KEY)
	req.Header.Add("x-krn", KAS_WALLET_KRN)

	res, err := httpClient.Do(req)
	if err != nil {
		c.String(-1, err.Error())
		return
	}

	// Step 4. Read and return back to the user the response of KAS.
	bodyContents, err := ioutil.ReadAll(res.Body)
	if err != nil {
		c.String(-1, err.Error())
		return
	}
	_ = res.Body.Close()

	c.String(200, string(bodyContents))
}

// AddStoreInfo registers a new store to Master Contract
func AddStoreInfo(c *gin.Context) {
	url := "https://wallet-api.klaytnapi.com/v2/tx/fd/contract/execute"
	params := struct {
        Name string `json:"name"`
        X string `json:"x"`
        Y string `json:"y"`
        Owner string `json:"owner"`
        ContractAddr string `json:"contract_addr"`
	}{}

	// Step 1. Get user inputs from the request
	if err := c.ShouldBindJSON(&params); err != nil {
		c.String(-1, "invalid input data" + err.Error())
		return
	}

	// Step 2. Prepare field values of contract execution transaction.
	// MASTER_CONTRACT_ABI is generated from the solidity code of Store Contract.
	_abi , err := abi.JSON(bytes.NewBufferString(MASTER_CONTRACT_ABI))
	if err != nil {
		c.String(-1, err.Error())
		return
	}

    // Pack function convert user inputs to the rlp-encoded parameter.
    // "addStore" is a function of Master Contract.
	inputParam, err := _abi.Pack("addStore", params.Name, params.X, params.Y, common.HexToAddress(params.Owner), common.HexToAddress(params.ContractAddr))
	if err != nil {
		c.String(-1, err.Error())
		return
	}

    // input format of the KAS API, /v2/tx/fd/contract/execute
	bodyData, err := json.Marshal(&kasExecuteTxFD{
        From: KAS_ACCOUNT,
        To: MasterContract,
		Value: "0x0",
		GasLimit: 8000000,
		Input: Encode(inputParam),
		Submit: true,
	})
	if err != nil {
		c.String(-1, err.Error())
		return
	}

	// Step 3. Call a KAS API with parameters and HTTP headers.
	// "Authorization" header should be set with your KAS API Key (e.g., "Basic xxxx...") .
	// "x-krn" header should indicate your KAS Wallet resource (e.g., "krn:1001:wallet:80:account:default").
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(bodyData))
	if err != nil {
		c.String(-1, err.Error())
		return
	}
	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("Authorization", KAS_API_KEY)
	req.Header.Add("x-krn", KAS_WALLET_KRN)

	res, err := httpClient.Do(req)
	if err != nil {
		c.String(-1, err.Error())
		return
	}

	// Step 4. Read and return back to the user the response of KAS.
	bodyContents, err := ioutil.ReadAll(res.Body)
	if err != nil {
		c.String(-1, err.Error())
		return
	}
	_ = res.Body.Close()

	c.String(200, string(bodyContents))
}

func GetTxReceipt(c *gin.Context) {
	url := "https://node-api.klaytnapi.com/v2/klaytn"
	params := struct {
		TxHash string `form:"tx_hash" json:"tx_hash"`
	}{}

	// Step 1. Get user inputs from the request
	if err := c.ShouldBindQuery(&params); err != nil {
		c.String(-1, "invalid input data" + err.Error())
		return
	}

	// Step 2. Prepare a Klaytn node method and parameters to use KAS Node API.
	// You can see the detailed information of node methods from
	// https://ko.docs.klaytn.foundation/dapp/json-rpc/api-references
	bodyData, _ := json.Marshal(&kasKlaytnRPC{
		JsonRpc: "2.0",
		Method: "klay_getTransactionReceipt",
		Params: []string{params.TxHash},
		Id: 1,
	})

	// Step 3. Call a KAS API with parameters and HTTP headers.
	// "Authorization" header should be set with your KAS API Key (e.g., "Basic xxxx...") .
	// "x-krn" header should indicate your KAS Node resource (e.g., "krn:1001:node").
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(bodyData))
	if err != nil {
		c.String(-1, err.Error())
		return
	}
	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("Authorization", KAS_API_KEY)
	req.Header.Add("x-krn", KAS_NODE_KRN)

	res, err := httpClient.Do(req)
	if err != nil {
		c.String(-1, err.Error())
		return
	}

	// Step 4. Read and return back to the user the response of KAS.
	bodyContents, err := ioutil.ReadAll(res.Body)
	if err != nil {
		c.String(-1, err.Error())
		return
	}
	_ = res.Body.Close()

	c.String(200, string(bodyContents))
}

function CheckTransactionReceipt(txHash) {
  let self = this;
  function getReceipt(txHash) {
    axios
      .get(klaybucks_backend + "/klaytn/receipt?tx_hash=" + txHash)
      .then((response) => {
        let result = response.data["result"];
        if (result !== null) {
          clearInterval(self.intervalId2);
          // check the result and process next steps
        }
      })
      .catch((error) => {
        console.log(error);
      });
  }

  self.intervalId2 = setInterval(getReceipt, 1000, txHash);
  setTimeout(clearInterval, 10000, self.intervalId2);
}

func CreateAccount(c *gin.Context){
	url := "https://wallet-api.klaytnapi.com/v2/account"

	// Step 1. Call a KAS API with parameters and HTTP headers.
	// "Authorization" header should be set with your KAS API Key (e.g., "Basic xxxx...") .
	// "x-krn" header should indicate your KAS Wallet resource (e.g., "krn:1001:wallet:80:account:default").
	req, err := http.NewRequest("POST", url, nil)
	if err != nil {
		c.String(-1, err.Error())
		return
	}
	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("Authorization", KAS_API_KEY)
	req.Header.Add("x-krn", KAS_NODE_KRN)

	res, err := httpClient.Do(req)
	if err != nil {
		c.String(-1, err.Error())
		return
	}

	// Step 2. Read and return back to the user the response of KAS.
	bodyContents, err := ioutil.ReadAll(res.Body)
	if err != nil {
		c.String(-1, err.Error())
		return
	}
	_ = res.Body.Close()

	c.String(200, string(bodyContents))
}

func GetStores(c *gin.Context) {
	url := "https://node-api.klaytnapi.com/v2/klaytn"

	// Step 1. Prepare "klay_call" API among Node APIs
	bodyData, _ := json.Marshal(&kasKlaytnRPC{
		JsonRpc: "2.0",
		Method: "klay_call",
		Params: []interface{}{
			structCall{
				From: KASAccount,
				To: MASTER_CONTRACT,
				Gas: "0x7A1200", // 8000000
				Data: MASTER_CONTRACT_ABI_GETSTORE,
			},
			"latest",
		},
		Id: 1,
	})

	// Step 2. Call a KAS API with parameters and HTTP headers.
	// "Authorization" header should be set with your KAS API Key (e.g., "Basic xxxx...") .
	// "x-krn" header should indicate your KAS Node resource (e.g., "krn:1001:node").
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(bodyData))
	if err != nil {
		c.String(-1, err.Error())
	}
	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("Authorization", KAS_API_KEY)
	req.Header.Add("x-krn", KAS_NODE_KRN)

	res, err := httpClient.Do(req)
	if err != nil {
		c.String(-1, err.Error())
		return
	}

	bodyContents, err := ioutil.ReadAll(res.Body)
	if err != nil {
		c.String(-1, err.Error())
		return
	}
	res.Body.Close()

	// Step 3. Parse the return of Node API
	var rpcRet struct {
		JsonRPC string `json:"jsonrpc"`
		Id int `json:"id"`
		Result string `json:"result"`
	}

	if err := json.Unmarshal(bodyContents, &rpcRet); err != nil {
		c.String(-1, err.Error())
		return
	}

	// Step 4. Parse the store information which is stored as an array in the Contract
	_abi , err := abi.JSON(bytes.NewBufferString(MASTER_CONTRACT_ABI))
	if err != nil {
		c.String(-1, err.Error())
		return
	}

	var storeArray []struct {
		Name string `json:"name"`
		X string `json:"x"`
		Y string `json:"y"`
		StoreOwner common.Address `json:"store_owner"`
		StoreContract common.Address `json:"store_contract"`
		Status uint8 `json:"status"`
	}

	if err := _abi.Unpack(&storeArray, "getStores", hexutil.MustDecode(rpcRet.Result)); err != nil {
		c.String(-1, err.Error())
		return
	}

	c.JSON(200, storeArray)
}

// Retrieves the receipt logs of the given contract address
RetrieveLogs = (address) => {
  let self = this;
  function getReceipt(address) {
    let hexBlockNumber = caver.utils.toHex(self.state.blockNumber);
    axios
      .get(
        klaybucks_backend +
          "getReceipts?from_block=" +
          hexBlockNumber +
          "&to_block=" +
          hexBlockNumber +
          "&contract=" +
          address
      )
      .then((response) => {
        self.setState((current) => ({
          blockNumber: self.state.blockNumber + 1,
        }));
        if (response.data !== null) {
          let current_receipts = response.data;
          // Add validation logic for the receipts
          current_receipts.map((item) => {
            let order = qs.parse(item.content);
            let receipt = {
              index: item.index,
              order: JSON.stringify(order),
              price: item.price,
              reward: self.CalculateReward(order),
              tid: item.payment_tx_id,
              status: "ordered",
            };
            self.setState((current) => ({
              receipts: self.state.receipts.concat(receipt),
            }));
            return item;
          });
        }
      })
      .catch((error) => {
        console.log(error);
      });
  }
  self.intervalId = setInterval(getReceipt, 1000, address);
};