package pstoremem

import (
	
	

	ic 
	
	pstore 
)

type memoryKeyBook struct {
	sync.RWMutex // same lock. wont happen a ton.
	pks          map[peer.ID]ic.PubKey
	sks          map[peer.ID]ic.PrivKey
}

var _ pstore.KeyBook = (*memoryKeyBook)(nil)

func () *memoryKeyBook {
	return &memoryKeyBook{
		pks: map[peer.ID]ic.PubKey{},
		sks: map[peer.ID]ic.PrivKey{},
	}
}

func ( *memoryKeyBook) () peer.IDSlice {
	.RLock()
	 := make(peer.IDSlice, 0, len(.pks)+len(.sks))
	for  := range .pks {
		 = append(, )
	}
	for  := range .sks {
		if ,  := .pks[]; ! {
			 = append(, )
		}
	}
	.RUnlock()
	return 
}

func ( *memoryKeyBook) ( peer.ID) ic.PubKey {
	.RLock()
	 := .pks[]
	.RUnlock()
	if  != nil {
		return 
	}
	,  := .ExtractPublicKey()
	if  == nil {
		.Lock()
		.pks[] = 
		.Unlock()
	}
	return 
}

func ( *memoryKeyBook) ( peer.ID,  ic.PubKey) error {
	// check it's correct first
	if !.MatchesPublicKey() {
		return errors.New("ID does not match PublicKey")
	}

	.Lock()
	.pks[] = 
	.Unlock()
	return nil
}

func ( *memoryKeyBook) ( peer.ID) ic.PrivKey {
	.RLock()
	defer .RUnlock()
	return .sks[]
}

func ( *memoryKeyBook) ( peer.ID,  ic.PrivKey) error {
	if  == nil {
		return errors.New("sk is nil (PrivKey)")
	}

	// check it's correct first
	if !.MatchesPrivateKey() {
		return errors.New("ID does not match PrivateKey")
	}

	.Lock()
	.sks[] = 
	.Unlock()
	return nil
}

func ( *memoryKeyBook) ( peer.ID) {
	.Lock()
	delete(.sks, )
	delete(.pks, )
	.Unlock()
}