package org.webslinger.resolver;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.ListIterator;

 import java.util.Map;

 import java.util.Set;

 import java.util.WeakHashMap;

 import java.util.concurrent.ConcurrentHashMap;

 import javax.imageio.spi.ServiceRegistry;

 public final class ObjectWalker {

     private final ConcurrentHashMap<String, ObjectResolver<?>> registry = new ConcurrentHashMap<String, ObjectResolver<?>>();

     public ObjectWalker() {

         ClassLoader loader = Thread.currentThread().getContextClassLoader();

         if (loader == null) loader = ObjectWalker.class.getClassLoader();

         Iterator<ObjectResolverInfo> it = ServiceRegistry.lookupProviders(ObjectResolverInfo.class, loader);

         while (it.hasNext()) {

             try {

                 ObjectResolverInfo info = it.next();

                 register(info.getType(), info.getResolver());

             } catch (RuntimeException e) {

             } catch (UnsupportedClassVersionError e) {

             }

         }

     }

     public void register(String name, ObjectResolver<?> resolver) {

         registry.put(name, resolver);

     }

     public Object get(Object object, ListIterator<String> it) {

         return get(object, it, false);

     }

     private Object get(Object object, ListIterator<String> it, boolean leaveEnding) {

         while (object != null && it.hasNext()) {

             String token = it.next();

             if (!it.hasNext() && leaveEnding) {

                 it.previous();

                 return object;

             }

             Object newObject;

             if (object instanceof ObjectLookup) {

                 ObjectLookup lookup = (ObjectLookup) object;

                 newObject = lookup.objectGet(token);

             } else {

                 newObject = doGet(object.getClass(), object, token);

             }

             if (newObject == null) {

                 it.previous();

                 return object;

             }

             object = newObject;

         }

         return object;

     }

     private <T> Object doGet(Class<T> type, Object object, String part) {

         ObjectResolver<T> resolver = getResolver(type);

         if (resolver == null) return null;

         return resolver.get(type.cast(object), part);

     }

     public String[] list(Object object, ListIterator<String> it) {

         object = get(object, it);

         if (object == null || it.hasNext()) return null;

         if (object instanceof ObjectLookup) {

             return ((ObjectLookup) object).objectList();

         }

         return doList(object.getClass(), object);

     }

     private <T> String[] doList(Class<T> type, Object object) {

         ObjectResolver<T> resolver = getResolver(type);

         return resolver.list(type.cast(object));

     }

     public boolean hasChildren(Object object, ListIterator<String> it) {

         object = get(object, it);

         if (object == null || it.hasNext()) return false;

         if (object instanceof ObjectLookup) {

             return ((ObjectLookup) object).objectHasChildren();

         }

         return doHasChildren(object.getClass(), object);

     }

     private <T> boolean doHasChildren(Class<T> type, Object object) {

         ObjectResolver<T> resolver = getResolver(type);

         return resolver.hasChildren(type.cast(object));

     }

     public ObjectResolver<?> getResolver(String name) {

         return registry.get(name);

     }

     public <T> ObjectResolver<T> getResolver(Class<T> clz) {

         return getResolver(clz, null);

     }

     public Class getType(Object object, ListIterator<String> it) {

         object = get(object, it, true);

         if (object == null || !it.hasNext()) return Void.TYPE;

         String part = it.next();

         if (it.hasNext()) return Void.TYPE;

         if (object instanceof ObjectLookup) {

             return ((ObjectLookup) object).getType(part);

         }

         return doGetType(object.getClass(), object, part);

     }

     private <T> Class doGetType(Class<T> type, Object object, String part) {

         ObjectResolver<T> resolver = getResolver(type);

         return resolver.getType(type.cast(object), part);

     }

     public char[] getChars(Object object, ListIterator<String> it) throws Exception {

         object = get(object, it, false);

         if (object == null || it.hasNext()) return null;

         //if (object instanceof ObjectLookup) {

         //    return ((ObjectLookup) object).getType(part);

         //}

         return getChars(object);

     }

     public char[] getChars(Object object) throws Exception {

         return doGetChars(object.getClass(), object);

     }

     private <T> char[] doGetChars(Class<T> type, Object object) throws Exception {

         ObjectResolver<T> resolver = getResolver(type);

         if (resolver == null) return null;

         return resolver.getChars(type.cast(object));

     }

     public void setChars(Object object, ListIterator<String> it, char[] chars) throws Exception {

         setChars(object, it, chars, 0, chars.length);

     }

     public void setChars(Object object, ListIterator<String> it, char[] chars, int offset, int length) throws Exception {

         object = get(object, it, true);

         if (object == null || !it.hasNext()) return;

         String part = it.next();

         if (it.hasNext()) return;

         //if (object instanceof ObjectLookup) {

         //    return ((ObjectLookup) object).getType(part);

         //}

         doSetChars(object.getClass(), object, part, chars, offset, length);

     }

     private <T, P> void doSetChars(Class<T> type, Object object, String part, char[] chars, int offset, int length) throws Exception {

         ObjectResolver<T> resolver = getResolver(type);

         Class<P> partType = resolver.getType(type.cast(object), part);

         ObjectResolver<P> typeResolver = getResolver(partType);

         if (typeResolver == null) return;

         Object value = typeResolver.newObject(partType, chars, offset, length);

         resolver.set(type.cast(object), part, value);

     }

     public Object getObject(String type, char[] chars) throws Exception {

         return getObject(type, chars, 0, chars.length);

     }

     public Object getObject(String type, char[] chars, int offset, int length) throws Exception {

         return getObject(Class.forName(type), chars, offset, length);

     }

     public Object getObject(Class<?> type, char[] chars) throws Exception {

         return getObject(type, chars, 0, chars.length);

     }

     public <T> Object getObject(Class<T> type, char[] chars, int offset, int length) throws Exception {

         ObjectResolver<T> typeResolver = getResolver(type);

         if (typeResolver == null) return null;

         return typeResolver.newObject(type, chars, offset, length);

     }

     private <T> ArrayResolver<T> getArrayResolver(Class<T> componentType) {

         return new ArrayResolver<T>(componentType);

     }

     private <T> ObjectResolver<T> getResolver(Class<T> clz, Set<Class> seen) {

         if (clz == null || clz.equals(Object.class)) return null;

         if (seen == null) seen = new HashSet<Class>();

         ObjectResolver resolver = registry.get(clz.getName());

         if (clz.isArray()) {

             resolver = getArrayResolver(clz.getComponentType());

         } else {

             if (resolver == null) {

                 seen.add(clz);

                 for (Class<?> intf: clz.getInterfaces()) {

                     resolver = getResolver(intf, seen);

                     if (resolver != null) break;

                 }

                 if (resolver == null) resolver = getResolver(clz.getSuperclass(), seen);

             }

         }

         return resolver;

     }

 }