package dslab.mailbox;

import dslab.authentication.User;
import dslab.protocol.Message;
import dslab.protocol.dmap.MessageMetadata;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Logger;

import static java.util.stream.Collectors.toList;

/**
 * A mailbox stores a bunch of messages for a user. A mailbox is where messages are stored after delivery
 * via DMTP is finished, and where messages are read from during DMAP sessions.
 */
public class Mailbox {

    private static final Logger LOG = Logger.getLogger(Mailbox.class.getSimpleName());
    private final Map<Integer, Message> messages = new ConcurrentHashMap<>();
    private final User owner;
    private final AtomicInteger mailIdSequence = new AtomicInteger();

    public Mailbox(User owner) {
        this.owner = owner;
    }

    @Override
    public String toString() {
        return "Mailbox{" + this.owner + ", " + messages.values().size() + " message(s) }";
    }

    public void deleteMessage(Integer messageId) throws MessageNotFoundException {
        var removedMessage = messages.remove(messageId);
        if (removedMessage == null)
            throw new MessageNotFoundException(messageId);
    }

    public Message get(Integer messageId) throws MessageNotFoundException {
        var message = messages.get(messageId);
        if (message == null)
            throw new MessageNotFoundException(messageId);
        return message;
    }

    public void put(Message message) {
        messages.put(mailIdSequence.incrementAndGet(), message);
        LOG.info("Put " + message + " into " + this + ".");
    }

    public Map<Integer, Message> getMessages() {
        return messages;
    }

    public List<MessageMetadata> getMessageMetadata(){
        return messages.entrySet().stream()
                .map(id_msg -> new MessageMetadata(id_msg.getKey(),id_msg.getValue()))
                .collect(toList());
    }
}