func (t *TrackManagementChain) CreateScheme(stub shim.ChaincodeStubInterface, args []string) pb.Response {
	//args[0]=schemeName
	//args[1]=startDate
	//args[2]=endDate
	//args[3]=payoutType
	//args[4]=sizeType
	//args[5]=slabCount
	//args[slabcount+6->(slabcount*3)+6]=payoutStartLimit
	//args[slabcount+7->(slabcount*3)+7]=payoutEndLimit
	//args[(slabcount*3)+8]=affectingUsersCount(let 3)
	//args[(slabcount*3)+9]=usertype1
	//args[(slabcount*3)+10]=userType2
	//args[(slabcount*3)+11]=userType3
	OemAddress, err := getAccountAddress(stub)
	if err != nil {
		return shim.Error("Chaincode:scheme:CreateScheme::Couldnt get address of the OEM")
	}
	if len(OemAddress) == 0 {
		return shim.Error("Chaincode:scheme:CreateScheme:: get address id null of the OEM")
	}

	Scheme := scheme{}
	txid := stub.GetTxID()
	Scheme.SchemeId = txid
	if len(args[0]) == 0 {
		return shim.Error("Chaincode:scheme:CreateScheme:: Name of the scheme can't be empty")
	}
	Scheme.Name = args[0]

	if len(args[1]) == 0 || len(args[2]) == 0 {
		return shim.Error("Chaincode:scheme:CreateScheme:: Tenure can't be blank")
	}

	var str = "T23:59:59+00:00"
	time1 := args[1] + str
	time2 := args[2] + str
	tenureEnd, err := time.Parse(time.RFC3339, time2)
	if err != nil {
		return shim.Error("Chaincode:scheme:CreateScheme:: Couldnt Parse Date")
	}
	tenureStart, err := time.Parse(time.RFC3339, time1)
	if err != nil {
		return shim.Error("Chaincode:scheme:CreateScheme:: Couldnt Parse Date")
	}

	diff := tenureStart.Before(tenureEnd)
	if diff {

		tenure := tenure{}
		tenure.StartDate = args[1]
		tenure.EndDate = args[2]
		Scheme.Tenure = tenure

		if len(args[3]) == 0 {
			return shim.Error("Chaincode:scheme:CreateScheme::Couldnt read payout type")
		}
		Scheme.PayoutType = args[3]

		if len(args[4]) == 0 {
			return shim.Error("Chaincode:scheme:CreateScheme::Couldnt read Sizetype")
		}

		Scheme.Sizetype = args[4]

		if len(args[5]) == 0 || len(args[6]) == 0 || len(args[7]) == 0 {
			return shim.Error("Chaincode:scheme:CreateScheme::Couldnt read Sizetype")
		}



		slabCount,err:=strconv.Atoi(args[5])
		if err!=nil {
			return shim.Error("Chaincode:scheme:CreateScheme::Couldnt typecaste")
		}
		var i int
		for i=6;i<6+slabCount*3; {


			Slab := slab{}
			payOutAmount, err := strconv.ParseFloat(args[i], 64)
			if err!=nil {
				return shim.Error("Chaincode:scheme:CreateScheme::Expecting amount float")
			}
			i++
			payoutStartLimit, err := strconv.Atoi(args[i])
			if err!=nil {
				return shim.Error("Chaincode:scheme:CreateScheme::Expecting payout start limit")
			}
			i++
			payoutEndLimit, err := strconv.Atoi(args[i])
			if err!=nil {
				return shim.Error("Chaincode:scheme:CreateScheme::Expecting payout end limit")
			}
			i++

			if payoutEndLimit <= payoutStartLimit {
				return shim.Error("Chaincode:scheme:CreateScheme::ENTER CORRECT LIMIT")
			}
			Slab.Payout = payOutAmount
			Slab.StartLimit = payoutStartLimit
			Slab.EndLimit = payoutEndLimit
			Scheme.Slabs =append(Scheme.Slabs,Slab)
		}


		userCount, err := strconv.Atoi(args[i])
		if err != nil {
			return shim.Error("Chaincode:scheme:CreateScheme::Couldnt type cast count")
		}
		i++
		if userCount == 0 {
			return shim.Error("Chaincode:scheme:CreateScheme::Affecting users can't be blank")
		}
		var arr []string
		j := i
		for j = i; j < i+userCount; j++ {
			arr = append(arr, args[j])
		}


		Scheme.ApplicableFor = arr

		SchemeAsBytes, err := json.Marshal(Scheme)
		if err != nil {
			return shim.Error("Chaincode:scheme:CreateScheme::Couldnt marshal scheme")
		}
		err = stub.PutState(Scheme.SchemeId, SchemeAsBytes)
		if err != nil {
			return shim.Error("Chaincode:scheme:CreateScheme::Couldnt putstate scheme")
		}

		OEMIndexKey, err := stub.CreateCompositeKey(OEMkey, []string{"OEM", Scheme.SchemeId})
		if err != nil {
			return shim.Error(err.Error())
		}
		value := []byte(Scheme.SchemeId)
		err = stub.PutState(OEMIndexKey, value)
		if err != nil {
			return shim.Error("Chaincode:scheme:CreateScheme::Couldnt putstate warehouse scheme")
		}

		for k := 0; k < len(arr); k++ {
			if arr[k] == "distributor" {

				userNameIndexKey, err := stub.CreateCompositeKey(DistributerKey, []string{arr[k], Scheme.SchemeId})
				if err != nil {
					return shim.Error(err.Error())
				}

				value := []byte(Scheme.SchemeId)
				err = stub.PutState(userNameIndexKey, value)
				if err != nil {
					return shim.Error("Chaincode:scheme:CreateScheme::Couldnt putstate Distributer scheme")
				}

			} else if arr[k] == "subdistributor" {
				userNameIndexKey, err := stub.CreateCompositeKey(SubDistributerKey, []string{arr[k], Scheme.SchemeId})
				if err != nil {
					return shim.Error(err.Error())
				}
				value := []byte(Scheme.SchemeId)
				err = stub.PutState(userNameIndexKey, value)
				if err != nil {
					return shim.Error("Chaincode:scheme:CreateScheme::Couldnt putstate SubDistributer scheme")
				}

			} else if arr[k] == "wholeseller" {
				userNameIndexKey, err := stub.CreateCompositeKey(WholeSellerKey, []string{arr[k], Scheme.SchemeId})
				if err != nil {
					return shim.Error(err.Error())
				}
				value := []byte(Scheme.SchemeId)
				err = stub.PutState(userNameIndexKey, value)
				if err != nil {
					return shim.Error("Chaincode:scheme:CreateScheme::Couldnt putstate WholeSeller scheme")
				}

			} else if arr[k] == "retailer" {
				userNameIndexKey, err := stub.CreateCompositeKey(Retailerkey, []string{arr[k], Scheme.SchemeId})
				if err != nil {
					return shim.Error(err.Error())
				}
				value := []byte(Scheme.SchemeId)
				err = stub.PutState(userNameIndexKey, value)
				if err != nil {
					return shim.Error("Chaincode:scheme:CreateScheme::Couldnt putstate Retailer scheme")
				}

			}else {
				return shim.Error("Chaincode:scheme:CreateScheme::No Proper Participant Type Given.")
			}
		}

	} else {
		return shim.Error("Chaincode:scheme:CreateScheme::Start Date Can't be before End-date")
	}

	return shim.Success(nil)
}