// recieve prepare request
func (pn *paxosNode) RecvPrepare(args *paxosrpc.PrepareArgs, reply *paxosrpc.PrepareReply) error {
	key := args.Key
	number := args.N
	value, ok := pn.vaMap[key]
	// first see if the key is a new key or not
	if !ok {
		value = nil
	}
	nk, ok := pn.naMap[key]
	if !ok {
		nk = -1
	}

	np, ok := pn.npMap[key]

	if !ok {
		np = -1
		pn.npMap[key] = np
	}

	// do prepare, decide give the vote or not
	if number > np {
		pn.npMap[key] = number
		reply.Status = paxosrpc.OK

		reply.N_a = nk
		reply.V_a = value
	} else {
		reply.Status = paxosrpc.Reject
	}
	return nil
}

// It will check whether the key is in the storage
// If so, return the value and set status as KeyFound
// If not, set status as Key Not Found
func (pn *paxosNode) RecvPrepare(args *paxosrpc.PrepareArgs, reply *paxosrpc.PrepareReply) error {
	recvKey := args.Key
	recvNum := args.N

	pn.propNum.propNumLock.Lock()
	defer pn.propNum.propNumLock.Unlock()

	if propNum, ok := pn.propNum.propNum[recvKey]; ok {
		if recvNum < propNum {
			reply.Status = paxosrpc.Reject
			reply.N_a = -1
		} else {
			reply.Status = paxosrpc.OK
			pn.propNum.propNum[recvKey] = recvNum
			pn.acceptValue.acceptMapLock.Lock()
			if acc_v, ok := pn.acceptValue.acceptValue[recvKey]; ok {
				reply.V_a = acc_v
				reply.N_a = pn.acceptValue.acceptNum[recvKey]
			} else {
				reply.V_a = nil
				reply.N_a = -1
			}
			pn.acceptValue.acceptMapLock.Unlock()
		}
	} else {
		pn.propNum.propNum[recvKey] = recvNum
		reply.Status = paxosrpc.OK
		reply.N_a = -1
	}
	return nil
}

func (pn *paxosNode) RecvPrepare(args *paxosrpc.PrepareArgs, reply *paxosrpc.PrepareReply) error {
	key := args.Key
	N := args.N

	// fmt.Println("recvprepare", pn.nodeID, args.N, args.Key)
	// find key mutex or create one
	pn.mutex.Lock()
	if pn.keyValueMutex[key] == nil {
		pn.keyValueMutex[key] = &sync.Mutex{}
	}
	pn.mutex.Unlock()
	// lock current key mutex
	pn.keyValueMutex[key].Lock()
	_, ok := pn.keyValue[key]
	if !ok {
		// fmt.Println("key not found", key)
		pn.keyValue[key] = &value{
			Key:   key,
			Value: nil,
			N_a:   -1,
			N_h:   -1,
			my_n:  -1,
		}
	} else {
		// fmt.Println("key found", key)
	}
	// get value
	value := pn.keyValue[key]
	// fmt.Println("recv prepare, before update", "my_n:", value.my_n, "my N_h:", value.N_h, "N:", N, "nodeID:", pn.nodeID)
	N_h := value.N_h
	// N_a := value.N_a
	// V_a := value.Value
	// assign reply values
	if N > N_h {
		reply.Status = paxosrpc.OK
		value.N_h = N
		// value.N_a = N
		pn.keyValue[key] = value
	} else {
		reply.Status = paxosrpc.Reject
	}
	reply.N_a = value.N_a
	reply.V_a = value.Value
	pn.keyValueMutex[key].Unlock()
	// fmt.Println("recvprepare unlock return", pn.nodeID, args.N, args.Key)

	return nil
}

func (pn *paxosNode) RecvPrepare(args *paxosrpc.PrepareArgs, reply *paxosrpc.PrepareReply) error {
	// update current logic time
	if pn.logicTime <= args.N/pn.timeFactor {
		pn.logicTime = args.N/pn.timeFactor + 1
	}

	// check if accept the prepare rpc
	if args.N < pn.nhMap[args.Key] {
		reply.Status = paxosrpc.Reject
	} else {
		pn.nhMap[args.Key] = args.N
		reply.N_a = pn.naMap[args.Key]
		reply.V_a = pn.vaMap[args.Key]
		reply.Status = paxosrpc.OK
	}
	return nil
}

// Receive a Prepare message from another Paxos Node. The message contains
// the key whose value is being proposed by the node sending the prepare
// message. This function should respond with Status OK if the prepare is
// accepted and Reject otherwise.
func (pn *paxosNode) RecvPrepare(args *paxosrpc.PrepareArgs, reply *paxosrpc.PrepareReply) error {
	// Upon receiving <Prepare, n, V>
	// If n < Nh
	//     reply with <accept-reject, Na, Va>
	// else
	//    Na = n; Va = V; Nh = n
	//     reply with <accept-ok>
	key := args.Key
	n := args.N
	pxi := pn.getInstance(key)
	pxi.mu.Lock()
	defer pxi.mu.Unlock()
	//reject if request is with a proposal number less than the highest seen by this node for this key
	if n < pxi.Nh {
		reply.Status = paxosrpc.Reject
		reply.N_a = pxi.Na
		reply.V_a = pxi.Va
	} else {
		pxi.Nh = n
		reply.Status = paxosrpc.OK
		reply.N_a = pxi.Na
		reply.V_a = pxi.Va
		if reply.V_a == nil {
			reply.N_a = -1
		}
	}

	return nil
}

func (pn *paxosNode) RecvPrepare(args *paxosrpc.PrepareArgs, reply *paxosrpc.PrepareReply) error {
	if _, ok := pn.highestSeen[args.Key]; !ok {
		pn.highestSeen[args.Key] = -1
	}
	if pn.highestSeen[args.Key] > args.N {
		reply.Status = paxosrpc.Reject
		reply.N_a = -1
		reply.V_a = nil

		return nil
	}
	if _, ok := pn.na[args.Key]; !ok {
		pn.na[args.Key] = -1
		pn.va[args.Key] = nil
	}
	pn.highestSeen[args.Key] = args.N
	reply.Status = paxosrpc.OK
	reply.N_a = pn.na[args.Key]
	reply.V_a = pn.va[args.Key]

	return nil
}

func (pn *paxosNode) RecvPrepare(args *paxosrpc.PrepareArgs, reply *paxosrpc.PrepareReply) error {
	key := args.Key
	N := args.N
	N_h, ok := pn.maxpropMap[key]
	//pn.acceptMutex.Lock()
	//prop, ok := pn.acceptMap[key]
	//pn.acceptMutex.Unlock()
	if ok && N < N_h {
		reply.Status = paxosrpc.Reject
	} else {
		pn.maxpropMap[key] = N
		reply.Status = paxosrpc.OK
		prop, ok := pn.acceptMap[key]
		if ok {
			reply.N_a = prop.N
			reply.V_a = prop.V
		} else {
			reply.N_a = -1
			reply.V_a = nil
		}
	}
	return nil
}