/*
 * Copyright (c) Johannes Brodwall <johannes@brodwall.com>, 2006
 *
 * Licensed under Creative Commons Deed 2.5
 *
 * You are free:
 *  to copy, distribute, display, and perform the work
 *  to make derivative works
 *  to make commercial use of the work
 *
 * Under the following conditions:
 *  Attribution. You must attribute the work in the manner specified by the author or licensor.
 *
 * For any reuse or distribution, you must make clear to others the license terms of this work.
 * Any of these conditions can be waived if you get permission from the copyright holder.
 *
 * Your fair use and other rights are in no way affected by the above.
 *
 * For full license text see: http://creativecommons.org/licenses/by/2.5/
 */

package com.brodwall.insanejava.lazyload.space;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.LazyLoader;

import com.brodwall.insanejava.lazyload.Category;
import com.brodwall.insanejava.lazyload.CategoryDao;
import com.brodwall.insanejava.lazyload.lazy.PagedLazyCollection;

public class SpaceCategoryDao implements CategoryDao {

    private Map idToTuples = new HashMap();

    private Map parentIdToIdList = new HashMap();

    private long nextId = 1;

    private Map sessionCache = new HashMap();

    public void clearSessionCache() {
        sessionCache.clear();
    }

    public void unloadFromSessionCache(Collection categories) {
        for (Iterator iter = categories.iterator(); iter.hasNext();) {
            Category element = (Category) iter.next();
            sessionCache.remove(element.getId());
        }
    }

    public boolean isLoaded(Long id) {
        return sessionCache.containsKey(id);
    }

    public Collection findByParentId(Long parentId, int offset, int length) {
        ArrayList result = new ArrayList();
        Iterator iter = getChildIdListFor(parentId).iterator();
        for (int i=0; i<offset && iter.hasNext(); i++) {
            iter.next();
        }
        for (int i=0; i<length && iter.hasNext(); i++) {
            Long element = (Long) iter.next();
            result.add(get(element));
        }
        return result;
    }

    public int countByParent(Long parentId) {
        return getChildIdListFor(parentId).size();
    }

    public Category get(Long id) {
        if (!idToTuples.containsKey(id)) {
            return null;
        }
        if (!isLoaded(id)) {
            Serializable[] tuple = (Serializable[]) idToTuples.get(id);
            sessionCache.put(id, tupleToObject(tuple));
        }
        return (Category) sessionCache.get(id);
    }


    public void initialize() {
        // ObjectSpace is ready immediately
    }

    public Long store(Category category) {
        if (category == null) {
            return null;
        }
        if (category.getParent() != null && category.getParent().getId() == null) {
            store(category.getParent());
        }
        if (category.getId() == null) {
            insert(category);
        } else {
            update(category);
        }
        return category.getId();
    }

    private void insert(Category category) {
        category.setId(new Long(nextId++));
        Serializable[] tuple = objectToTuple(category);
        idToTuples.put(category.getId(), tuple);
        sessionCache.put(category.getId(), category);
        if (category.getParent() != null) {
            getChildIdListFor(category.getParent().getId()).add(category.getId());
        }

        for (Iterator iter = category.getSubcategories().iterator(); iter.hasNext();) {
            store((Category) iter.next());
        }
    }

    private void update(Category category) {
        Serializable[] tuple = objectToTuple(category);
        idToTuples.put(category.getId(), tuple);
        sessionCache.put(category.getId(), category);
        if (category.getParent() != null) {
            getChildIdListFor(category.getParent().getId()).add(category.getId());
        }
        if (category.getSubcategories() instanceof PagedLazyCollection) {
            Collection newObjects = ((PagedLazyCollection)category.getSubcategories()).getAddendum();
            for (Iterator iter = newObjects.iterator(); iter.hasNext();) {
                Category element = (Category) iter.next();
                store(element);
            }
        }
    }

    private Collection getChildIdListFor(Long parentId) {
        if (!parentIdToIdList.containsKey(parentId)) {
            parentIdToIdList.put(parentId, new ArrayList());
        }
        return (Collection) parentIdToIdList.get(parentId);
    }

    private Serializable[] objectToTuple(Category category) {
        Long parentId = category.getParent() != null ? category.getParent().getId() : null;
        return new Serializable[] { category.getId(), category.getName(), new Integer(category.getCreationYear()), parentId };
    }

    private Category tupleToObject(Serializable[] tuple) {
        Category category = new Category((String)tuple[1], ((Integer)tuple[2]).intValue());
        category.setId((Long) tuple[0]);
        category.setParent(lazyGet((Long) tuple[3]));
        category.setSubcategories(lazyFindByParentId(category.getId()));
        return category;
    }

    private Category lazyGet(final Long key) {
        if (key == null) {
            return null;
        }
        if (isLoaded(key)) {
            return (Category) sessionCache.get(key);
        }
        return (Category) Enhancer.create(Category.class, new LazyLoader() {
            public Object loadObject() throws Exception {
                return get(key);
            }
        });
    }

    protected Collection lazyFindByParentId(final Long parentId) {
        return new PagedLazyCollection(countByParent(parentId)) {
            public Collection loadPage(int offset, int pageSize) {
                return findByParentId(parentId, offset, pageSize);
            }
            public void unloadPage(Collection collection) {
                unloadFromSessionCache(collection);
            }
        };
    }

}