package com.gridnine.commons.visited;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import org.hibernate.Criteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.opencms.security.CmsPrincipal;
import org.opencms.util.CmsUUID;

import com.gridnine.commons.hibernate.HibernateUtil;
import com.gridnine.linkon.catalog.contacts.Person;

public class VisitedResourcesHandler {

    private static volatile VisitedResourcesHandler instance;

    private Map<UUID, UUID[]> news;

    private VisitedResourcesHandler() {

        List<Record> records = getRecords();

        for (Record rec : records) {
            news.put(rec.getResource(), deserializeUUID(rec.getUsers()));
        }

    }

    public static VisitedResourcesHandler getInstance() {
        if (instance == null) {
            synchronized (VisitedResourcesHandler.class) {
                if (instance == null) {
                    instance = new VisitedResourcesHandler();
                }
            }
        }
        return instance;
    }

    private String serializeUUID(UUID[] uuids) {
        return Arrays.toString(uuids);
    }

    private UUID[] deserializeUUID(String uuidString) {

        String[] arrUUIDs = uuidString.split(",");
        UUID[] uuids = new UUID[arrUUIDs.length];

        for (int i = 0; i < arrUUIDs.length; i++) {
            uuids[i] = UUID.fromString(arrUUIDs[i]);
        }

        return uuids;
    }

    public boolean isRead(UUID resource, UUID user) {
        UUID[] usersUUIDs = news.get(resource);
        if (usersUUIDs != null) {
            return Arrays.binarySearch(usersUUIDs, user) >= 0;
        }
        return false;
    }

    public boolean isRead(CmsPrincipal resource, CmsPrincipal user) {
        return isRead(resource.getId(), user.getId());
    }

    public boolean isRead(CmsUUID resource, CmsUUID user) {
        return isRead(UUID.fromString(resource.getStringValue()),
                UUID.fromString(user.getStringValue()));
    }

    public void addReadPage(UUID userUUID, UUID resourceUUID) {
        UUID[] usersUUIDs = news.get(resourceUUID);

        Record rec = null;
        if (usersUUIDs == null) {
            rec = new Record();
            rec.setResource(resourceUUID);
            rec.setUsers(userUUID.toString());
            saveRecord(rec);
            news.put(resourceUUID, new UUID[] { userUUID });
        } else {
            if (Arrays.binarySearch(usersUUIDs, userUUID) < 0) {
                rec = getRecord(resourceUUID);
                usersUUIDs = Arrays.copyOf(usersUUIDs, usersUUIDs.length + 1);
                usersUUIDs[usersUUIDs.length - 1] = userUUID;
                Arrays.sort(usersUUIDs);
                rec.setUsers(serializeUUID(usersUUIDs));
                saveRecord(rec);
                news.put(resourceUUID, usersUUIDs);
            }
        }

    }

    private static List<Record> getRecords() {

        Criteria crit =
                HibernateUtil.currentSession().createCriteria(Person.class);

        crit.addOrder(Order.asc("resource")); //$NON-NLS-1$

        return crit.list();
    }

    private static Record getRecord(UUID resource) {

        Criteria crit =
                HibernateUtil.currentSession().createCriteria(Person.class);

        crit.add(Restrictions.eq("resource", resource));

        return (Record) crit.uniqueResult();
    }

    private void saveRecord(Record rec) {
        HibernateUtil.currentSession().saveOrUpdate(rec);
        HibernateUtil.commitTransaction();
    }

}