/*

Copyright (C) 2003  Franklin Schmidt <frank@gustos.com>

*/

package nabble.model;

import fschmidt.db.DbDatabase;
import fschmidt.db.Listener;
import fschmidt.util.mail.Mail;
import fschmidt.util.mail.MailException;
import fschmidt.util.mail.MailHome;
import nabble.modules.ModuleManager;
import nabble.naml.compiler.Template;
import nabble.naml.compiler.TemplatePrintWriter;
import nabble.naml.namespaces.BasicNamespace;
import nabble.view.web.template.NabbleNamespace;
import nabble.view.web.template.NodePageNamespace;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;


public final class ModelHome {
	private ModelHome() {}  // never

	private static final Logger logger = LoggerFactory.getLogger(ModelHome.class);

	public static final String AVATAR_SMALL = "avatar24.png";
	public static final String AVATAR_BIG = "avatar100.png";

	public static volatile long lastDigestRun = System.currentTimeMillis();

	public static Site newSite(String type,String subject,String message,Message.Format msgFmt,String email,String username)
		throws ModelException
	{
		return DbSiteCreator.newSite(type,subject,message,msgFmt,email,username);
	}

	public static Site restoreSiteToOldId(String filename) {
		return DbSiteCreator.restoreSiteToOldId(new File(filename));
	}

	public static Site restoreSiteToNewId(String filename) {
		return DbSiteCreator.restoreSiteToNewId(new File(filename));
	}

	public static void validateEmail(String email) throws ModelException {
		UserImpl.validateEmail(email);
	}

	public static String hideEmail(String emailTo) {
		return "[hidden email]";
	}

	public static String hideAllEmails(String txt) {
		return MessageUtils.hideAllEmails(txt);
	}

	public static Site getSite(long id) {
		SiteKey siteKey = SiteKey.getInstance(id);
		if( siteKey.siteGlobal() == null )
			return null;
		return siteKey.siteGlobal().site();
	}

	public static void setRemoteAddr(Site site, String removeAddr) {
		((SiteImpl) site).siteGlobal().setRemoteAddr(removeAddr);
	}

	// force these classes to add their listeners first
	static {
		Init.modelHomeStarted = true;
		NodeImpl.nop();
		Lucene.nop();
		DailyNumber.nop();
		FileUpload.nop();
		nabble.view.lib.MyJtpServlet.nop();
		SubscriptionImpl.nop();
		ModuleManager.nop();
	}

	private static Set<Node> doneSet(Map<String,Object> transMap) {
		if( transMap==null )
			return new HashSet<Node>();
		@SuppressWarnings("unchecked")
		Set<Node> done = (Set<Node>)transMap.get("doneNodes");
		if( done == null ) {
			done = new HashSet<Node>();
			transMap.put("doneNodes",done);
		}
		return done;
	}

	public static void addDescendantChangeListener(final Listener<Node> listener) {
		Listener<Node> myListener = new Listener<Node>() {
			public void event(final Node node) {
				if( ModelHome.insideImportProcedure.get() )
					return;
				DbDatabase db = node.getSite().getDb();
				final Map<String,Object> transMap = db.transactionMap();
				db.runAfterCommit(new Runnable(){public void run(){
					Set<Node> done = doneSet(transMap);
					for( Node n : node.getAncestors() ) {
						if( done.add(n) )
							listener.event(n);
					}
				}});
			}
		};
		NodeImpl.childChangeListeners.add(myListener);
		NodeImpl.addPostUpdateListener(myListener);
		NodeImpl.addPostDeleteListener(myListener);
		NodeImpl.addPostInsertListener(new Listener<Node>() {
			public void event(final Node node) {
				DbDatabase db = node.getSite().getDb();
				final Map<String,Object> transMap = db.transactionMap();
				db.runAfterCommit(new Runnable(){public void run(){
					Set<Node> done = doneSet(transMap);
					NodeIterator<? extends Node> ancestors = node.getAncestors();
					done.add(ancestors.next());  // skip self
					for( Node n : ancestors ) {
						if( done.add(n) )
							listener.event(n);
					}
				}});
			}
		});
	}

	public static void addSiteChangeListener(Listener<Site> listener) {
		SiteImpl.addChangeListener(listener);
	}

	public static void addSitePreChangeListener(Listener<Site> listener) {
		SiteImpl.addPreChangeListener(listener);
	}

	public static void addNodeChangeListener(final Listener<Node> listener) {
		NodeImpl.addChangeListener(listener);
	}

	public static void addNodeInsertListener(final Listener<Node> listener) {
		NodeImpl.addPostInsertListener(listener);
	}

	public static void addNodeDeleteListener(final Listener<Node> nodeDeleteListener) {
		NodeImpl.addPostDeleteListener(nodeDeleteListener);
	}

	public static void addNodePreUpdatedListener(final Listener<Node> listener) {
		NodeImpl.preUpdateListeners.add(listener);
	}

	public static void addGotParentListener(Listener<Node> listener) {
		NodeImpl.gotParentListeners.add(listener);
	}

	public static void addUserInsertListener(final Listener<User> listener) {
		UserImpl.addPostInsertListener(listener);
	}

	public static void addUserPreUpdatedListener(final Listener<User> listener) {
		UserImpl.preUpdateListeners.add(listener);
	}

	static ThreadLocal<Boolean> insideImportProcedure = new ThreadLocal<Boolean>() {
		protected Boolean initialValue() {
			return Boolean.FALSE;
		}
	};

	public static void beginImport() {
		insideImportProcedure.set(true);
	}

	public static void endImport() {
		insideImportProcedure.set(false);
	}

	public static void preloadMessages(List<Node> nodes) {
		NodeImpl.preloadMessages(nodes);
	}

	public static String assignmentCondition(User user,Integer priority) {
		if( user==null && priority==null )
			return null;
		StringBuilder buf = new StringBuilder();
		if( user != null ) {
			buf.append( "assigned_user=" ).append( user.getId() );
		}
		if( priority != null ) {
			if( buf.length() > 0 )
				buf.append( " and " );
			buf.append( "assigned_priority=" ).append( priority );
		}
		return buf.toString();
	}



	public static Long getSiteIdFromDomain(String customDomain) {
		return SiteGlobal.getSiteIdFromDomain(customDomain);
	}


	public static final String noReply = "no-reply@nabble.com";
	static final String bounces = "bounces@n2.nabble.com";

	public static void send(Mail mail) throws MailException {
		if( mail.getFrom().getAddrSpec().equals(noReply) ) {
			MailHome.getDefaultSmtpServer().sendFrom(mail, bounces);
		} else {
			MailHome.getDefaultSmtpServer().send(mail);
		}
	}

	public static void send(Mail mail, String smtpFrom) throws MailException {
		if( mail.getFrom().getAddrSpec().equals(noReply) ) {
			MailHome.getDefaultSmtpServer().sendFrom(mail, bounces);
		} else {
			MailHome.getDefaultSmtpServer().sendFrom(mail, smtpFrom);
		}
	}


	public static <S,T> ExtensionFactory<S,T> standardExtensionFactory(final String name,final Class<S> sourceClass,final Class<T> extensionClass) {
		return new ExtensionFactory<S,T>() {

			public String getName() {
				return name;
			}

			public Class<T> extensionClass() {
				return extensionClass;
			}

			public T construct(S source) {
				try {
					Constructor<T> constructor = extensionClass.getConstructor(sourceClass);
					constructor.setAccessible(true);
					return constructor.newInstance(source);
				} catch(NoSuchMethodException e) {
					throw new RuntimeException(e);
				} catch(InstantiationException e) {
					throw new RuntimeException(e);
				} catch(IllegalAccessException e) {
					throw new RuntimeException(e);
				} catch(InvocationTargetException e) {
					Throwable cause = e.getCause();
					if( cause instanceof Error )
						throw (Error)cause;
					if( cause instanceof RuntimeException )
						throw (RuntimeException)cause;
					throw new RuntimeException(e);
				}
			}

			public T construct(S source,ResultSet rs) {
				return construct(source);
			}

			public Serializable getExportData(S source) {
				return null;
			}

			public void saveExportData(S source,Serializable data) {
				throw new RuntimeException();
			}
		};
	}

	public static <T> void addSiteExtensionFactory(ExtensionFactory<Site,T> factory) {
		SiteImpl.addExtensionFactory(factory);
	}

	public static <T> void addNodeExtensionFactory(ExtensionFactory<Node,T> factory) {
		NodeImpl.addExtensionFactory(factory);
	}

	public static <T> void addUserExtensionFactory(ExtensionFactory<User,T> factory) {
		UserImpl.addExtensionFactory(factory);
	}


	public static List<Site> getSitesForTask(String task) throws SQLException {
		List<Site> sites = new ArrayList<Site>();
		for( SiteKey siteKey : SiteKey.getSiteKeys(task) ) {
			try {
				sites.add( siteKey.site() );
			} catch(UpdatingException e) {}  // skip it
		}
		return sites;
	}

}