package de.thedevstack.conversationsplus.services.avatar;

import android.graphics.Bitmap;
import android.net.Uri;

import java.util.ArrayList;

import de.thedevstack.conversationsplus.entities.Account;
import de.thedevstack.conversationsplus.entities.Bookmark;
import de.thedevstack.conversationsplus.entities.Contact;
import de.thedevstack.conversationsplus.entities.Conversation;
import de.thedevstack.conversationsplus.entities.ListItem;
import de.thedevstack.conversationsplus.entities.Message;
import de.thedevstack.conversationsplus.entities.MucOptions;
import de.thedevstack.conversationsplus.utils.AvatarUtil;
import de.thedevstack.conversationsplus.utils.ImageUtil;
import de.thedevstack.conversationsplus.utils.UIHelper;

/**
 */
public final class AvatarCache {

    private static final String PREFIX_CONTACT = "contact";
    private static final String PREFIX_CONVERSATION = "conversation";
    private static final String PREFIX_ACCOUNT = "account";
    private static final String PREFIX_GENERIC = "generic";

    private final ArrayList<Integer> sizes = new ArrayList<>();
    private final static AvatarCache INSTANCE = new AvatarCache();

    private AvatarCache() {
    }

    private static Bitmap get(final Contact contact, final int size, boolean cachedOnly) {
        final String KEY = key(contact, size);
        Bitmap avatar = ImageUtil.getBitmapFromCache(KEY);
        if (avatar != null || cachedOnly) {
            return avatar;
        }
        if (contact.getProfilePhoto() != null) {
            avatar = ImageUtil.cropCenterSquare(Uri.parse(contact.getProfilePhoto()), size);
        }
        if (avatar == null && contact.getAvatar() != null) {
            avatar = AvatarUtil.getAvatar(contact.getAvatar(), size);
        }
        if (avatar == null) {
            avatar = get(contact.getDisplayName(), size, cachedOnly);
        }
        ImageUtil.addBitmapToCache(KEY, avatar);
        return avatar;
    }

    public static Bitmap get(final MucOptions.User user, final int size, boolean cachedOnly) {
        Contact c = user.getContact();
        if (c != null && (c.getProfilePhoto() != null || c.getAvatar() != null)) {
            return get(c, size, cachedOnly);
        } else {
            return getImpl(user, size, cachedOnly);
        }
    }

    private static Bitmap getImpl(final MucOptions.User user, final int size, boolean cachedOnly) {
        final String KEY = key(user, size);
        Bitmap avatar = ImageUtil.getBitmapFromCache(KEY);
        if (avatar != null || cachedOnly) {
            return avatar;
        }
        if (user.getAvatar() != null) {
            avatar = AvatarUtil.getAvatar(user.getAvatar(), size);
        }
        if (avatar == null) {
            Contact contact = user.getContact();
            if (contact != null) {
                avatar = get(contact, size, cachedOnly);
            } else {
                avatar = get(user.getName(), size, cachedOnly);
            }
        }
        ImageUtil.addBitmapToCache(KEY, avatar);
        return avatar;
    }

    public static void clear(Contact contact) {
        synchronized (INSTANCE.sizes) {
            for (Integer size : INSTANCE.sizes) {
                ImageUtil.removeBitmapFromCache(key(contact, size));
            }
        }
    }

    private static String key(Contact contact, int size) {
        synchronized (INSTANCE.sizes) {
            if (!INSTANCE.sizes.contains(size)) {
                INSTANCE.sizes.add(size);
            }
        }
        return PREFIX_CONTACT + "_" + contact.getAccount().getJid().toBareJid() + "_"
                + contact.getJid() + "_" + String.valueOf(size);
    }

    private static String key(MucOptions.User user, int size) {
        synchronized (INSTANCE.sizes) {
            if (!INSTANCE.sizes.contains(size)) {
                INSTANCE.sizes.add(size);
            }
        }
        return PREFIX_CONTACT + "_" + user.getAccount().getJid().toBareJid() + "_"
                + user.getFullJid() + "_" + String.valueOf(size);
    }

    public static Bitmap get(ListItem item, int size) {
        return get(item,size,false);
    }

    public static Bitmap get(ListItem item, int size, boolean cachedOnly) {
        if (item instanceof Contact) {
            return get((Contact) item, size,cachedOnly);
        } else if (item instanceof Bookmark) {
            Bookmark bookmark = (Bookmark) item;
            if (bookmark.getConversation() != null) {
                return get(bookmark.getConversation(), size, cachedOnly);
            } else {
                return get(bookmark.getDisplayName(), size, cachedOnly);
            }
        } else {
            return get(item.getDisplayName(), size, cachedOnly);
        }
    }

    public static Bitmap get(Conversation conversation, int size) {
        return get(conversation,size,false);
    }

    public static Bitmap get(Conversation conversation, int size, boolean cachedOnly) {
        if (conversation.getMode() == Conversation.MODE_SINGLE) {
            return get(conversation.getContact(), size, cachedOnly);
        } else {
            return get(conversation.getMucOptions(), size, cachedOnly);
        }
    }

    public static void clear(MucOptions options) {
        synchronized (INSTANCE.sizes) {
            for (Integer size : INSTANCE.sizes) {
                ImageUtil.removeBitmapFromCache(key(options, size));
            }
        }
    }

    private static String key(MucOptions options, int size) {
        synchronized (INSTANCE.sizes) {
            if (!INSTANCE.sizes.contains(size)) {
                INSTANCE.sizes.add(size);
            }
        }
        return PREFIX_CONVERSATION + "_" + options.getConversation().getUuid()
                + "_" + String.valueOf(size);
    }

    public static Bitmap get(Account account, int size) {
        return get(account, size, false);
    }

    public static Bitmap get(Account account, int size, boolean cachedOnly) {
        final String KEY = key(account, size);
        Bitmap avatar = ImageUtil.getBitmapFromCache(KEY);
        if (avatar != null || cachedOnly) {
            return avatar;
        }
        avatar = AvatarUtil.getAvatar(account.getAvatar(), size);
        if (avatar == null) {
            avatar = get(account.getJid().toBareJid().toString(), size,false);
        }
        ImageUtil.addBitmapToCache(KEY, avatar);
        return avatar;
    }

    public static Bitmap get(Message message, int size, boolean cachedOnly) {
        final Conversation conversation = message.getConversation();
        if (message.getStatus() == Message.STATUS_RECEIVED) {
            Contact c = message.getContact();
            if (c != null && (c.getProfilePhoto() != null || c.getAvatar() != null)) {
                return get(c, size, cachedOnly);
            } else if (message.getConversation().getMode() == Conversation.MODE_MULTI){
                MucOptions.User user = conversation.getMucOptions().findUser(message.getCounterpart().getResourcepart());
                if (user != null) {
                    return getImpl(user,size,cachedOnly);
                }
            }
            return get(UIHelper.getMessageDisplayName(message), size, cachedOnly);
        } else  {
            return get(conversation.getAccount(), size, cachedOnly);
        }
    }

    public static void clear(Account account) {
        synchronized (INSTANCE.sizes) {
            for (Integer size : INSTANCE.sizes) {
                ImageUtil.removeBitmapFromCache(key(account, size));
            }
        }
    }

    public static void clear(MucOptions.User user) {
        synchronized (INSTANCE.sizes) {
            for (Integer size : INSTANCE.sizes) {
                ImageUtil.removeBitmapFromCache(key(user, size));
            }
        }
    }

    private static String key(Account account, int size) {
        synchronized (INSTANCE.sizes) {
            if (!INSTANCE.sizes.contains(size)) {
                INSTANCE.sizes.add(size);
            }
        }
        return PREFIX_ACCOUNT + "_" + account.getUuid() + "_"
                + String.valueOf(size);
    }

    public static Bitmap get(String name, int size) {
        return get(name,size,false);
    }

    public static Bitmap get(final String name, final int size, boolean cachedOnly) {
        final String KEY = key(name, size);
        Bitmap bitmap = ImageUtil.getBitmapFromCache(KEY);
        if (bitmap != null || cachedOnly) {
            return bitmap;
        }

        bitmap = AvatarBitmapUtil.createAvatarBitmap(name, size);
        ImageUtil.addBitmapToCache(KEY, bitmap);
        return bitmap;
    }

    private static String key(String name, int size) {
        synchronized (INSTANCE.sizes) {
            if (!INSTANCE.sizes.contains(size)) {
                INSTANCE.sizes.add(size);
            }
        }
        return PREFIX_GENERIC + "_" + name + "_" + String.valueOf(size);
    }

    public static void clear(Conversation conversation) {
        if (conversation.getMode() == Conversation.MODE_SINGLE) {
            clear(conversation.getContact());
        } else {
            clear(conversation.getMucOptions());
        }
    }

    private static Bitmap get(MucOptions mucOptions, int size,  boolean cachedOnly) {
        final String KEY = key(mucOptions, size);
        Bitmap bitmap = ImageUtil.getBitmapFromCache(KEY);
        if (bitmap != null || cachedOnly) {
            return bitmap;
        }

        bitmap = AvatarBitmapUtil.createAvatarBitmap(mucOptions, size);
        ImageUtil.addBitmapToCache(KEY, bitmap);
        return bitmap;
    }
}