package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "strconv"

    "github.com/hyperledger/fabric/core/chaincode/shim"
    sc "github.com/hyperledger/fabric/protos/peer"
    )

// Define the Smart Contract structure

type SmartContract struct {
}

//Define assets structure

type Asset struct {
    asset_id string `json:"asset_id"`
    asset_name string `json:"asset_name"`
    owner_aadhar int `json:"owner_aadhar"`
    owner_name string `json:"owner_name"`
    debt bool `json:"debt"`
    lamount int `json:"lamount"`
    objection string `json:"objection"`
    }


func (s *SmartContract) Init(APIstub shim.ChaincodeStubInterface) sc.Response {
    return shim.Success(nil)
}

// The calling application program has also specified the particular smart contract function to be called, with arguments

func (s *SmartContract) Invoke(APIstub shim.ChaincodeStubInterface) sc.Response {

    function, args := APIstub.GetFunctionAndParameters()

    if function == "initLedger"{
        return s.initLedger(APIstub)
    }

    if function == "transfer_asset"{
        return s.transfer_asset(APIstub,args)
    }

    if function == "create_asset"{
        return  s.create_asset(APIstub,args)
    }

    if function == "view_asset" {
        return s.view_asset(APIstub,args)
    }


    return shim.Error("Invalid Smart Contract function name.")
}

//stores some sample assets

func (s *SmartContract) initLedger(APIstub shim.ChaincodeStubInterface) sc.Response {
    assets := []Asset{
        Asset{asset_id:"A101", asset_name:"1bhk", owner_aadhar:101, owner_name:"praveen", debt:false, lamount:0, objection:"nill"},
        Asset{asset_id:"A102", asset_name:"factory",owner_aadhar:102, owner_name:"arun", debt:false, lamount:0, objection:"nill"},
        Asset{asset_id:"A103", asset_name:"abt school", owner_aadhar:103, owner_name:"kevin", debt:true, lamount:100000, objection:"nill"},
        Asset{asset_id:"A104", asset_name:"2bhk", owner_aadhar:104, owner_name:"baaruni",debt:false, lamount:0, objection:"1case"},
    }

    i := 0

    for i< len(assets)  {
        assetAsBytes, _ :=json.Marshal(assets[i])
        APIstub.PutState(assets[i].asset_id, assetAsBytes)
        i++
    }

    return shim.Success(nil)
}

func (s *SmartContract) create_asset(APIstub shim.ChaincodeStubInterface, args[] string) sc.Response  {
    if len(args)!=7 {
        return shim.Error("Incorrect number of arguments expected 7")
    }
    taadhar, _ :=strconv.Atoi(args[2])
    tdept, _ := strconv.ParseBool(args[4])
    tlamount, _ := strconv.Atoi(args[5])
    var asset = Asset{asset_id:args[0], asset_name:args[1], owner_aadhar:taadhar, owner_name:args[3], debt:tdept, lamount:tlamount, objection:args[6]}
    assetAsBytes, _ := json.Marshal(asset)
    APIstub.PutState(asset.asset_id,assetAsBytes)
    return shim.Success(nil)
}

func (s *SmartContract) transfer_asset(APIstub shim.ChaincodeStubInterface, args[] string) sc.Response{

    if len(args) !=3 {
        return shim.Error("Incorrect number of arguments expected 3")
    }

    assetAsBytes, _ :=APIstub.GetState(args[0])
    asset := Asset{}

    json.Unmarshal(assetAsBytes, &asset)

    if (asset.objection!="nill")||(asset.debt!=false){
        return shim.Error("Asset cannot be transfer as it has some issues")
    }
    asset.owner_aadhar, _ = strconv.Atoi(args[1])

    assetAsBytes, _ =json.Marshal(asset)
    APIstub.PutState(args[0],assetAsBytes)

    return shim.Success(nil)

}

func (s *SmartContract) view_asset(APIstub shim.ChaincodeStubInterface, args[] string) sc.Response  {
    if len(args) !=1{
        return shim.Error("Invalid number of arguments expected 1")
    }

    assetAsBytes, _ :=APIstub.GetState(args[0])
    asset := Asset{}

    json.Unmarshal(assetAsBytes, &asset)
    return shim.Success(assetAsBytes)
}