func (pn *paxosNode) GetNextProposalNumber(args *paxosrpc.ProposalNumberArgs, reply *paxosrpc.ProposalNumberReply) error {
	pn.propNumLock.Lock()
	defer pn.propNumLock.Unlock()

	reply.N = pn.nodePropNum
	pn.nodePropNum += pn.numNodes
	return nil
}

func (pn *paxosNode) GetNextProposalNumber(args *paxosrpc.ProposalNumberArgs, reply *paxosrpc.ProposalNumberReply) error {
	key := args.Key
	var n int
	if m, found := pn.highestSeen[key]; found {
		n = (m/pn.numNodes+1)*pn.numNodes + pn.nodeID
	} else {
		n = pn.nodeID
	}
	pn.highestSeen[key] = n
	reply.N = n
	return nil
}

// GetNextProposalNumber generates a proposal number which will be passed to
// Propose. Proposal numbers should not repeat, and for a particular node
// they should be strictly increasing.
func (pn *paxosNode) GetNextProposalNumber(args *paxosrpc.ProposalNumberArgs, reply *paxosrpc.ProposalNumberReply) error {
	// Will just give the Max([Nh/k]*k + id , )
	key := args.Key
	pxi := pn.getInstance(key)

	pxi.mu.RLock()
	defer pxi.mu.RUnlock()

	replyN := (pxi.Nh/pn.numNodes+1)*pn.numNodes + pn.id
	reply.N = replyN

	return nil
}

// This function is used to generate the next proposal number given the user input
func (pn *paxosNode) GetNextProposalNumber(args *paxosrpc.ProposalNumberArgs, reply *paxosrpc.ProposalNumberReply) error {
	fmt.Println("get number")
	key := args.Key
	pNumber, ok := pn.pNumberMap[key]
	if !ok {
		pNumber = -1
	}

	newNumber := pNumber + 1
	reply.N = newNumber*pn.numNodes + pn.srvId
	pn.pNumberMap[key] = newNumber
	fmt.Println("getnumber: ", reply.N)
	return nil
}

func (pn *paxosNode) GetNextProposalNumber(args *paxosrpc.ProposalNumberArgs, reply *paxosrpc.ProposalNumberReply) error {
	// just increment the clock and calculate the proposal number
	N_my, ok1 := pn.clockMap[args.Key]
	N_h, ok2 := pn.maxpropMap[args.Key]
	highest_time := 0
	if ok1 && ok2 {
		if N_my > N_h/pn.numNodes {
			highest_time = N_my
		} else {
			highest_time = N_h / pn.numNodes
		}
	} else if ok1 {
		highest_time = N_my
	} else if ok2 {
		highest_time = N_h / pn.numNodes
	}
	pn.clockMap[args.Key] = highest_time + 1
	reply.N = pn.clockMap[args.Key]*pn.numNodes + pn.id
	return nil
}

func (pn *paxosNode) GetNextProposalNumber(args *paxosrpc.ProposalNumberArgs, reply *paxosrpc.ProposalNumberReply) error {
	reply.N = pn.logicTime*pn.timeFactor + pn.id
	return nil
}

func (pn *paxosNode) GetNextProposalNumber(args *paxosrpc.ProposalNumberArgs, reply *paxosrpc.ProposalNumberReply) error {
	key := args.Key
	pn.mutex.Lock()
	if pn.keyValueMutex[key] == nil {
		pn.keyValueMutex[key] = &sync.Mutex{}
	}
	pn.mutex.Unlock()
	// lock current key mutex
	pn.keyValueMutex[key].Lock()

	if pn.keyValue[key] == nil {
		pn.keyValue[key] = &value{
			Key:   key,
			Value: nil,
			N_a:   -1,
			N_h:   -1,
			my_n:  -1,
		}
	}

	val := pn.keyValue[key]
	my_n := val.my_n
	N_h := val.N_h
	// reply.N = math.Max(my_n, N_h) + 1
	if my_n > N_h {
		reply.N = my_n
	} else {
		reply.N = N_h
	}
	// fmt.Println("GetNextProposalNumber", reply.N, my_n, N_h)
	reply.N = (reply.N+pn.numNodes-pn.nodeID)/pn.numNodes*pn.numNodes + pn.nodeID
	pn.keyValueMutex[key].Unlock()

	// fmt.Println("my_n", my_n, "N_h", N_h, "replyN", reply.N)
	tempValue := pn.keyValue[args.Key]
	tempValue.my_n = reply.N
	pn.keyValue[args.Key] = tempValue

	if pn.savedkeyValue[key] == nil {
		pn.savedkeyValue[key] = &value{
			Key:   args.Key,
			Value: nil,
			N_a:   -1,
			N_h:   -1,
			my_n:  -1,
		}
	}
	retChan := make(chan int, 1)
	// proposalNumberArgs := &paxosrpc.ProposalNumberArgs{
	// 	Key: args.Key,
	// }
	// proposalNumberReply := &paxosrpc.ProposalNumberReply{}
	// pn.GetNextProposalNumber(proposalNumberArgs, proposalNumberReply)
	// fmt.Println("get new proposal number", proposalNumberReply.N)
	newArgs := &paxosrpc.ProposeArgs{
		Key: args.Key,
		N:   reply.N,
		V:   nil,
	}
	// fmt.Println("Prepare phase")
	for nodeID, hostPort := range pn.hostMap {
		pn.ProposeByNode(nodeID, hostPort, newArgs, retChan)
		<-retChan
	}
	return nil
}