package org.ijsolutions.testbench;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.mail.internet.InternetAddress;

import org.apache.commons.lang3.time.DurationFormatUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.entermediadb.asset.Asset;
import org.entermediadb.asset.MediaArchive;
import org.entermediadb.asset.scanner.AssetImporter;
import org.entermediadb.asset.search.AssetSearcher;
import org.entermediadb.email.PostMail;
import org.entermediadb.email.TemplateWebEmail;
import org.ijsolutions.testbench.course.CourseSearcher;
import org.ijsolutions.testbench.edit.QuestionEditor;
import org.ijsolutions.testbench.learninggroup.LearningGroup;
import org.ijsolutions.testbench.learninggroup.LearningGroupSearcher;
import org.ijsolutions.testbench.livetest.LiveTestManager;
import org.joda.time.Period;
import org.joda.time.format.PeriodFormatter;
import org.joda.time.format.PeriodFormatterBuilder;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.netevolved.tincan.BenchAnalytics;
import org.netevolved.tincan.TinCan;
import org.netevolved.tincan.TinCanIDAssistant;
import org.netevolved.twilio.TwilioManager;
import org.netevolved.websocket.BenchServer;
import org.oneliveweb.live.streams.LiveStreamManager;
import org.openedit.BaseWebPageRequest;
import org.openedit.Data;
import org.openedit.ModuleManager;
import org.openedit.OpenEditException;
import org.openedit.WebPageRequest;
import org.openedit.cache.CacheManager;
import org.openedit.data.BaseData;
import org.openedit.data.QueryBuilder;
import org.openedit.data.Searcher;
import org.openedit.data.SearcherManager;
import org.openedit.event.EventManager;
import org.openedit.event.WebEvent;
import org.openedit.hittracker.HitTracker;
import org.openedit.hittracker.SearchQuery;
import org.openedit.page.Page;
import org.openedit.page.PageProperty;
import org.openedit.page.Permission;
import org.openedit.page.manage.PageManager;
import org.openedit.profile.UserProfile;
import org.openedit.repository.ContentItem;
import org.openedit.store.Product;
import org.openedit.users.User;
import org.openedit.users.UserManager;
import org.openedit.util.DateStorageUtil;
import org.openedit.util.IntCounter;
import org.openedit.util.PathUtilities;
import org.openedit.util.RequestUtils;

public class TestBench extends BaseData {
	private static final Log log = LogFactory.getLog(TestBench.class);

	protected String fieldCatalogId;
	protected String fieldApplicationId;

	protected ModuleManager fieldModuleManager;
	protected QuestionArchive fieldQuestionArchive;
	protected CategoryArchive fieldCategoryArchive;
	protected SearcherManager fieldSearcherManager;
	protected TestBuilder fieldTestBuilder;
	protected QuestionEditor fieldQuestionEditor;
	protected File fieldTestDirectory;
	protected TestPlanArchive fieldPlanArchive;
	protected PageManager fieldPageManager;
	protected MediaArchive fieldMediaArchive;
	protected String fieldMode;
	protected IntCounter fieldIntCounter;
	protected TinCanIDAssistant fieldTinCanAssistant;
	protected BenchAnalytics fieldBenchAnalytics;
	protected BenchServer fieldBenchServer;
	protected CacheManager fieldCacheManager;

	public CacheManager getCacheManager() {
		return fieldCacheManager;
	}

	public void setCacheManager(CacheManager cacheTracker) {
		fieldCacheManager = cacheTracker;
	}

	public BenchServer getBenchServer() {
		if (fieldBenchServer == null) {
			fieldBenchServer = (BenchServer) getModuleManager().getBean("benchServer");

		}

		return fieldBenchServer;
	}

	public TwilioManager getTwilioManager() {
		if (fieldTwilioManager == null) {
			fieldTwilioManager = (TwilioManager) getModuleManager().getBean(getCatalogId(), "twilioManager");

		}

		return fieldTwilioManager;
	}

	public void setTwilioManager(TwilioManager inTwilioManager) {
		fieldTwilioManager = inTwilioManager;
	}

	protected TwilioManager fieldTwilioManager;

	public BenchAnalytics getBenchAnalytics() {
		if (fieldBenchAnalytics == null) {
			fieldBenchAnalytics = (BenchAnalytics) getModuleManager().getBean(getCatalogId(), "benchAnalytics");

		}

		return fieldBenchAnalytics;
	}

	public QueryBuilder query(String inSearchType) {
		return getSearcher(inSearchType).query();
	}

	public void setBenchAnalytics(BenchAnalytics inBenchAnalytics) {
		fieldBenchAnalytics = inBenchAnalytics;
	}

	public TinCanIDAssistant getTinCanAssistant() {
		if (fieldTinCanAssistant == null) {
			fieldTinCanAssistant = (TinCanIDAssistant) getModuleManager().getBean(getCatalogId(), "tinCanIDAssistant");

		}

		return fieldTinCanAssistant;
	}

	public void setTinCanAssistant(TinCanIDAssistant inTinCanAssistant) {
		fieldTinCanAssistant = inTinCanAssistant;
	}

	protected TinCan fieldTinCan;

	public TinCan getTinCan() {
		if (fieldTinCan == null) {
			fieldTinCan = (TinCan) getModuleManager().getBean(getCatalogId(), "tinCan");

		}

		return fieldTinCan;
	}

	public void setTinCan(TinCan inTinCan) {
		fieldTinCan = inTinCan;
	}

	protected PostMail fieldPostMail;

	public PostMail getPostMail() {
		if (fieldPostMail == null) {
			fieldPostMail = (PostMail) getModuleManager().getBean("postMail");

		}

		return fieldPostMail;
	}

	public void setPostMail(PostMail inPostMail) {
		fieldPostMail = inPostMail;
	}

	protected EventManager fieldEventManager;

	public EventManager getEventManager() {
		return fieldEventManager;
	}

	public void setEventManager(EventManager inEventManager) {
		fieldEventManager = inEventManager;
	}

	public String getMode() {
		return fieldMode;
	}

	public void setMode(String inMode) {
		fieldMode = inMode;
	}

	public MediaArchive getMediaArchive() {
		if (fieldMediaArchive == null) {
			fieldMediaArchive = (MediaArchive) getModuleManager().getBean(getCatalogId(), "mediaArchive");
		}

		return fieldMediaArchive;
	}

	public void setMediaArchive(MediaArchive inMediaArchive) {
		fieldMediaArchive = inMediaArchive;
	}

	public PageManager getPageManager() {
		return fieldPageManager;
	}

	public void setPageManager(PageManager inPageManager) {
		fieldPageManager = inPageManager;
	}

	public TestBuilder getTestBuilder(String testType) {
		if (testType == null || testType.equals("")) {
			testType = "default";
		}
		TestBuilder builder = (TestBuilder) getModuleManager().getBean(getCatalogId(), testType + "TestBuilder");
		if (builder == null) {
			builder = (TestBuilder) getModuleManager().getBean(getCatalogId(), "defaultTestBuilder");
		}
		return builder;

	}

	public void setTestBuilder(TestBuilder inTestBuilder) {
		fieldTestBuilder = inTestBuilder;
	}

	public CategoryArchive getCategoryArchive() {
		if (fieldCategoryArchive == null) {
			fieldCategoryArchive = (CategoryArchive) getModuleManager().getBean(getCatalogId(),
					"questionCategoryArchive");
		}

		return fieldCategoryArchive;
	}

	public QuestionArchive getQuestionArchive() {
		if (fieldQuestionArchive == null) {
			fieldQuestionArchive = (QuestionArchive) getModuleManager().getBean(getCatalogId(), "testquestionArchive");
		}

		return fieldQuestionArchive;

	}

	public String getCatalogId() {
		return fieldCatalogId;
	}

	public void setCatalogId(String inCatalogId) {
		fieldCatalogId = inCatalogId;
	}

	public ModuleManager getModuleManager() {
		return fieldModuleManager;
	}

	public void setModuleManager(ModuleManager inModuleManager) {
		fieldModuleManager = inModuleManager;
	}

	public SearcherManager getSearcherManager() {
		return fieldSearcherManager;
	}

	public void setSearcherManager(SearcherManager searcherManager) {
		fieldSearcherManager = searcherManager;
	}

	public String getTestBenchHome() {
		return "/" + getCatalogId();
	}

	public QuestionSearcher getQuestionSearcher() {
		return (QuestionSearcher) getSearcherManager().getSearcher(getCatalogId(), "question");
	}

	public TestSearcher getTestSearcher() {
		return (TestSearcher) getSearcherManager().getSearcher(getCatalogId(), "test");
	}

	public Test buildTest(String inString, TestPlan inStructions) throws Exception {

		return getTestBuilder(inString).createTest(this, inStructions);
	}

	public void saveTest(Test inTest) {
		getTestSearcher().saveData(inTest, inTest.getUser());

	}

	public Test loadTest(String inTestId, String inUser) {
		return (Test) getTestSearcher().searchById(inTestId);

	}

	public TestManager getTestArchive() {
		return getTestSearcher().getTestManager();
	}

	public void saveQuestions(List inQuestionsToSave) throws Exception {
		for (Iterator iterator = inQuestionsToSave.iterator(); iterator.hasNext();) {
			Question question = (Question) iterator.next();
			getQuestionArchive().saveQuestion(question);
		}

	}

	public Question getQuestion(String inId) {
		try {
			return getQuestionArchive().getQuestion(inId);
		} catch (Exception e) {
			throw new OpenEditException(e);
		}
	}

	public List getQuestionsInCategory(Category inCategory) throws Exception {
		if (inCategory == null) {
			return null;
		}
		List assets = new ArrayList();
		SearchQuery q = getQuestionSearcher().createSearchQuery();
		q.addMatches("category", inCategory.getId());

		HitTracker hits = getQuestionSearcher().search(q);
		if (hits == null) {
			return assets;
		}
		for (Iterator it = hits.iterator(); it.hasNext();) {
			Data doc = (Data) it.next();
			String id = doc.get("id");
			Question asset = getQuestion(id);
			if (asset != null) {
				assets.add(asset);
			} else {
				log.info("Cannot find asset with id " + id);
			}
		}
		return assets;
	}

	public QuestionEditor getQuestionEditor() {
		// TODO Auto-generated method stub
		return fieldQuestionEditor;
	}

	public Category getCategory(String inCatid) {
		return getCategoryArchive().getCategory(inCatid);
	}

	public File getTestDirectory() {
		if (fieldTestDirectory == null) {
			PageManager manager = (PageManager) getModuleManager().getBean("pageManager");
			ContentItem item = manager.getRepository().get("/" + getCatalogId());
			fieldTestDirectory = new File(item.getAbsolutePath());
		}
		return fieldTestDirectory;
	}

	public String getQuestionImage(Question question) {
		if (question == null) {
			return null;
		}
		String questionpath = "/" + getCatalogId() + "/data/questions/images/" + question.getId()
				+ "/questionimage.jpg";
		Page questionpage = getPageManager().getPage(questionpath);
		if (questionpage.exists()) {
			return questionpath;
		}
		String questionimage = question.get("questionimage");

		questionpath = "/" + getCatalogId() + "/data/questions/images/" + questionimage;
		questionpage = getPageManager().getPage(questionpath);
		if (questionpage.exists()) {
			return questionpath;
		}

		return null;
	}

	public String getCategoryImage(Question question) {
		if (question == null) {
			return null;
		}
		if (question.getDefaultCategory() != null) {
			String questionpath = "/" + getCatalogId() + "/data/categories/images/"
					+ question.getDefaultCategory().getId() + "/questionimage.jpg";
			Page questionpage = getPageManager().getPage(questionpath);
			if (questionpage.exists()) {
				return questionpath;
			}

			String questionimage = question.getDefaultCategory().get("categoryimage");

			questionpath = "/" + getCatalogId() + "/images/" + questionimage;
			questionpage = getPageManager().getPage(questionpath);
			if (questionpage.exists()) {
				return questionpath;
			}
		}
		return null;
	}

	public String getResponseImage(Response response) {
		if (response == null) {
			return null;
		}
		String questionpath = "/" + getCatalogId() + "/data/questions/images/" + response.getId()
				+ "/questionimage.jpg";
		Page questionpage = getPageManager().getPage(questionpath);
		if (questionpage.exists()) {
			return questionpath;
		}
		String questionimage = response.get("responseimage");
		if (questionimage == null) {
			return null;
		}
		questionpath = "/" + getCatalogId() + "/data/questions/images/" + questionimage;
		questionpage = getPageManager().getPage(questionpath);
		if (questionpage.exists()) {
			return questionpath;
		}
		return null;
	}

	public TestPlanArchive getTestPlanArchive() {

		if (fieldPlanArchive == null) {
			fieldPlanArchive = (TestPlanArchive) getModuleManager().getBean(getCatalogId(), "testPlanArchive");
		}

		return fieldPlanArchive;

	}

	public CourseSearcher getCourseSearcher() {
		return (CourseSearcher) getSearcherManager().getSearcher(getCatalogId(), "course");
	}

	public LearningGroupSearcher getLearningGroupSearcher() {
		return (LearningGroupSearcher) getSearcherManager().getSearcher(getCatalogId(), "learningGroup");
	}

	public Course getCourse(String inString) {
		return getCourseSearcher().loadCourse(inString);
	}

	public LearningGroup getLearningGroup(String inString) {
		return getLearningGroupSearcher().loadLearningGroup(inString);
	}

	public TestPlan getTestPlan(String inId) {
		return getTestPlanArchive().getTestPlan(inId);
	}

	public String getApplicationId() {
		return fieldApplicationId;
	}

	public void setApplicationId(String inApplicationId) {
		fieldApplicationId = inApplicationId;
	}

	public String getProperty(String inKey) {
		return get(inKey);
	}

	public String get(String inKey) {
		String mode = getMode();
		if (mode == null) {
			mode = "default";
		}

		Data target = getSearcherManager().getData(getCatalogId(), "testbenchsetting", mode);
		if (target == null) {
			// throw new OpenEditException("Mode set to non-default but settings do not
			// exist!");

		}
		if (target != null) {
			String string = target.get(inKey);
			return string;
		}
		return null;

	}

	public boolean showEntry(WebPageRequest inReq, TestPlan plan, TestNode inNode) {
		if (plan == null) {
			return true;
		}
		if (inNode.getQuestion() == null) {
			return true;
		}
		String path = "/WEB-INF/data/" + getCatalogId() + "/testplans/" + plan.getId() + ".xml";
		String planentry = inNode.get("planentry");
		if (planentry != null) {
			inReq.putPageValue("node", inNode);

			Page linkpage = getPageManager().getPage(path, inReq.getUser() != null);
			Permission filter = linkpage.getPermission(planentry);

			if (filter != null) {
				if (filter.getRootFilter() == null) {
					return true;
				}
				WebPageRequest req = inReq.copy(linkpage);
				req.putPageValue("node", inNode);

				boolean value = filter.passes(req);
				return value;
			}
			return true;

		} else {
			return true;
		}
	}

	public boolean canSubmit(WebPageRequest inReq, Test inTest) {
		for (Iterator iterator = inTest.getNodes().iterator(); iterator.hasNext();) {
			TestNode type = (TestNode) iterator.next();
			if (type == null) {
				return true;
			}
			if (type.getQuestion() == null) {
				return true;
			}
			if (showEntry(inReq, inTest.getTestPlan(), type) && type.getQuestion().getBoolean("required")
					&& !type.hasResponse()) {
				return false;
			}
		}
		return true;

	}

	public void addUserToClass(String userid, String learningGroupId, String role, HashMap extraproperties) {
		if (userid == null) {
			return;
		}
		Searcher studentclasses = getSearcherManager().getSearcher(getCatalogId(), "studentclasses");
		Data record = studentclasses.query().exact("userprofile", userid).exact("learninggroup", learningGroupId)
				.searchOne();
		if (record == null) {
			record = studentclasses.createNewData();
		}
		record.setSourcePath(learningGroupId);
		record.setId(userid + "-" + learningGroupId);
		record.setProperty("userprofile", userid);
		record.setProperty("learninggroup", learningGroupId);
		record.setProperty("grouprole", role);
		record.setValue("addeddate", new Date());
		for (Iterator iterator = extraproperties.keySet().iterator(); iterator.hasNext();) {
			String key = (String) iterator.next();
			Object val = extraproperties.get(key);
			record.setValue(key, val);
		}

		studentclasses.saveData(record, null);

		// fireLearningEvent(getUserManager().getUser(userid), "initialized",
		// getData("learningGroup", learningGroupId), "learningGroup");

		assignStudentNumber(userid);

	}

	public void addUserToClass(String userid, String learningGroupId, String role) {
		addUserToClass(userid, learningGroupId, role, new HashMap());
	}

	public void removeUserFromClass(String userid, String learningGroupId) {
		Searcher studentclasses = getSearcherManager().getSearcher(getCatalogId(), "studentclasses");
		Data record = studentclasses.query().exact("userprofile", userid).exact("learninggroup", learningGroupId)
				.searchOne();
		if (record != null) {
			studentclasses.delete(record, null);
		}

		// assignStudentNumber(userid);

	}

	public void assignStudentNumber(String inUserid) {
		Searcher searcher = (Searcher) getSearcherManager().getSearcher(getCatalogId(), "user");
		Data userprofile = (Data) searcher.searchById(inUserid);

		if (userprofile != null && userprofile.get("studentid") == null) {
			userprofile.setProperty("studentid", nextStudentNumber());
			searcher.saveData(userprofile, null);

		}

	}

	public HitTracker getTestPlansForCourse(String inCourseId) {
		Searcher studentclasses = getSearcherManager().getSearcher(getCatalogId(), "grouptest");
		HitTracker hits = studentclasses.query().exact("learningGroup", inCourseId).search();
		return hits;
	}

	public String getSetting(String inId) {

		Data settings = getSearcherManager().getData(getCatalogId(), "testbenchsetting", getMode());
		if (settings != null) {
			return settings.get(inId);
		}
		return null;
	}

	public boolean isSettingTrue(String inId) {
		Data settings = getSearcherManager().getData(getCatalogId(), "testbenchsetting", getMode());
		if (settings != null) {
			return Boolean.parseBoolean(settings.get(inId));
		}
		return false;
	}

	public boolean is(String inId) {
		return isSettingTrue(inId);
	}

	
	public boolean isTrue(String inId) {
		return isSettingTrue(inId);
	}

	public HitTracker getCoursesForUser(String inUser) {

		Searcher classlist = getSearcherManager().getSearcher(getCatalogId(), "studentclasses");
		if (inUser == null) {
			return null;
		}
		HitTracker hits = classlist.query().match("userprofile", inUser).search();
		return hits;
	}

	public boolean checkInstructor(User user, String courseGroup) {
		if (user == null) {
			return false;
		}
		HitTracker hits = getSearcherManager().getSearcher(getCatalogId(), "studentclasses").query()
				.exact("grouprole", "instructor").exact("userprofile", user.getId()).exact("learninggroup", courseGroup)
				.search();
		return hits.size() > 0;
	}

	public Searcher getSearcher(String inSearchType) {
		return getSearcherManager().getSearcher(getCatalogId(), inSearchType);
	}

	public Data getData(String inSearchType, String inId) {
		return getSearcherManager().getData(getCatalogId(), inSearchType, inId);
	}

	public Data findResumableTest(String inUser, String inCourse, String inClass, String inPlanId) {
		TestSearcher searcher = (TestSearcher) getSearcher("test");

		SearchQuery query = searcher.createSearchQuery();
		query.addMatches("user", inUser);
		query.addMatches("plan", inPlanId);
		query.addSortBy("dateDown");
		if (inCourse != null) {
			query.addMatches("course", inCourse);
		}
		if (inClass != null) {
			query.addMatches("class", inClass);
		}

		HitTracker hits = searcher.search(query);
		if (hits.size() > 0) {
			return hits.get(0);
		}

		return null;

	}

	protected IntCounter getIntCounter() {
		if (fieldIntCounter == null) {
			synchronized (this) {

				if (fieldIntCounter == null) {
					fieldIntCounter = new IntCounter();
					fieldIntCounter.setLabelName("idCount");

					String path = null;

					// if( fieldIndexRootFolder != null)
					// {
					// path = "/WEB-INF/data/" + getCatalogId() +"/"+ getIndexRootFolder() + "/" +
					// getSearchType() + "/idcounter.properties";
					// }
					// else
					// {
					path = "/WEB-INF/data/" + getCatalogId() + "/studentcounter.properties";
					// }
					Page prop = getPageManager().getPage(path);
					File file = new File(prop.getContentItem().getAbsolutePath());
					file.getParentFile().mkdirs();
					fieldIntCounter.setCounterFile(file);
				}
			}
		}
		return fieldIntCounter;
	}

	public synchronized String nextStudentNumber() {
		StringBuffer id = new StringBuffer("O");
		String countString = String.valueOf(getIntCounter().incrementCount());
		int zeros = 6 - countString.length();
		for (int i = 0; i < zeros; i++) {
			id.append("0");
		}
		id.append(countString);

		return id.toString();
	}

	public int getRemainingCap(String inLearningGroup) {
		LearningGroup group = getLearningGroup(inLearningGroup);
		Searcher classlist = getSearcherManager().getSearcher(getCatalogId(), "studentclasses");

		HitTracker hits = classlist.query().match("learninggroup", inLearningGroup).match("grouprole", "student")
				.search();
		return group.getCap() - hits.size();
	}

	public int getRemainingCap(LearningGroup inLearningGroup) {
		return getRemainingCap(inLearningGroup.getId());
	}

	// public ArrayList getClassesForProduct(Product p)
	// {
	// if(p == null){
	// return null;
	// }
	// List classes = (List) p.getValues("classlist");
	// ArrayList groups = new ArrayList();
	// if (classes != null)
	// {
	// for (Iterator iterator = classes.iterator(); iterator.hasNext();)
	// {
	// String classid = (String) iterator.next();
	// LearningGroup g = getLearningGroup(classid);
	// if (g != null)
	// {
	// groups.add(g);
	// }
	// }
	// }
	// String classtemplate = p.get("classtemplate");
	// if (classtemplate != null && classtemplate.trim().length() > 0)
	// {
	// Searcher groupsearcher = getLearningGroupSearcher();
	//
	// HitTracker bytemplate = groupsearcher.query().match("classtemplate",
	// classtemplate).sort("startdate").search();
	// for (Iterator iterator = bytemplate.iterator(); iterator.hasNext();)
	// {
	// Data target = (Data) iterator.next();
	// LearningGroup g = getLearningGroup(target.getId());
	// if (g != null && !groups.contains(g))
	// {
	// groups.add(g);
	//
	// }
	//
	// }
	// }
	// return groups;
	//
	// }

	public UserManager getUserManager() {

		return (UserManager) getModuleManager().getBean(getCatalogId(), "userManager");
	}

	public String clean(String inFragment) {
		if (inFragment == null) {
			return "";
		}
		return Jsoup.parse(inFragment).text();

	}

	public String clean(String inFragment, int length) {
		if (inFragment == null) {
			return "";
		}
		
		int length2 = inFragment.length();
		if (length2 > length) {
			String text = Jsoup.parse(inFragment).text();
			
			
			StringBuffer buffer = new StringBuffer();
			String[] words = text.split("\\s+");
			
			
			for (int i = 0; i < words.length; i++) {
				String nextword = words[i];
				if ((buffer.length() + nextword.length()) > length) {
					return buffer.toString();
				}
				buffer.append(nextword);
				buffer.append(" ");
			}

			return buffer.toString();
		}
		return clean(inFragment);

	}

	public ArrayList getClassesForProduct(Product p) {
		if (p == null) {
			return null;
		}
		List classes = (List) p.getValues("classlist");
		ArrayList groups = new ArrayList();
		if (classes != null) {
			for (Iterator iterator = classes.iterator(); iterator.hasNext();) {
				String classid = (String) iterator.next();
				LearningGroup g = getLearningGroup(classid);
				if (g != null) {
					groups.add(g);
				}
			}
		}
		String classtemplate = p.get("classtemplate");
		if (classtemplate != null && classtemplate.trim().length() > 0) {
			Searcher groupsearcher = getLearningGroupSearcher();

			HitTracker bytemplate = groupsearcher.query().match("classtemplate", classtemplate).sort("startdate")
					.search();
			for (Iterator iterator = bytemplate.iterator(); iterator.hasNext();) {
				Data target = (Data) iterator.next();
				LearningGroup g = getLearningGroup(target.getId());
				if (g != null && !groups.contains(g)) {
					groups.add(g);

				}

			}
		}
		return groups;

	}

	public void sendWelcomeEmail(User inUser, String inMessage) {
		try {
			MediaArchive archive = getMediaArchive();

			String templatepage = "/" + getApplicationId()
					+ "/views/modules/userprofile/edit/admin/welcometemplate.html";
			RequestUtils rutil = (RequestUtils) getModuleManager().getBean("requestUtils");

			BaseWebPageRequest context = (BaseWebPageRequest) rutil.createVirtualPageRequest(templatepage, inUser,
					null);

			TemplateWebEmail mailer = getPostMail().getTemplateWebEmail();
			mailer.loadSettings(context);
			mailer.setMailTemplatePath(templatepage);

			context.putPageValue("target", inUser);
			context.putPageValue("message", inMessage);

			context.putPageValue("password", getUserManager().decryptPassword(inUser));

			InternetAddress recipient = new InternetAddress();
			recipient.setAddress(inUser.getEmail());

			recipient.setPersonal(inUser.toString());
			mailer.setRecipient(recipient);

			mailer.send();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			throw new OpenEditException(e);
		}

	}

	public void sendEmail(User inUser, WebPageRequest inReq, String inSubject) {
		sendEmail(inUser, inReq, inSubject, null);
	}

	public void sendEmail(User inUser, WebPageRequest inReq, String inSubject, List attachments) {
		try {
			MediaArchive archive = getMediaArchive();

			String templatepage = inReq.findValue("emaillayout");
			WebPageRequest context = inReq.copy(archive.getPageManager().getPage(templatepage));

			TemplateWebEmail mailer = getPostMail().getTemplateWebEmail();
			mailer.loadSettings(context);
			mailer.setMailTemplatePath(templatepage);
			mailer.setSubject(inSubject);
			if (attachments != null) {
				mailer.setFileAttachments(attachments);
			}

			context.putPageValue("target", inUser);
			ArrayList<InternetAddress> recipients = new ArrayList();

			InternetAddress recipient = new InternetAddress();
			recipient.setAddress(inUser.getEmail());
			recipient.setPersonal(inUser.toString());
			recipients.add(recipient);

			if (inUser.get("email2") != null) {

				recipient = new InternetAddress();
				recipient.setAddress(inUser.get("email2"));
				recipient.setPersonal(inUser.toString());
				recipients.add(recipient);
			}
			if (inUser.get("email3") != null) {

				recipient = new InternetAddress();
				recipient.setAddress(inUser.get("email3"));
				recipient.setPersonal(inUser.toString());
				recipients.add(recipient);

			}

			mailer.setRecipients(recipients);

			mailer.send();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			throw new OpenEditException(e);
		}

	}

	public void clearCaches() {
		getTestPlanArchive().clear();
		getCourseSearcher().clear();
		getLearningGroupSearcher().clear();
		getMediaArchive().clearAll();
		getMediaArchive().clearCaches();
		getMediaArchive().getPropertyDetailsArchive().clearCache();

	}

	public Object getBean(String inBean) {
		return getModuleManager().getBean(getCatalogId(), inBean);
	}

	public void saveSetting(String inKey, Object inValue) {
		Data settings = getSearcherManager().getData(getCatalogId(), "testbenchsetting", getMode());
		if (settings != null) {
			settings.setValue(inKey, inValue);
		}
		getMediaArchive().saveData("testbenchsetting", settings);

	}

	public Date getDateSetting(String inId) {
		Data settings = getSearcherManager().getData(getCatalogId(), "testbenchsetting", getMode());
		if (settings != null) {
			return (Date) settings.getValue(inId);
		}
		return null;
	}

	public String getSiteRoot() {
		String serverroot = getSetting("domainroot");
		if (serverroot != null) {
			return serverroot;
		}

		String root = "http://localhost:8080";
		PageProperty property = getPageManager().getPage("/" + getApplicationId() + "/index.html").getPageSettings()
				.getProperty("siteroot");
		if (property != null) {
			root = property.getValue();
		}

		return root;
	}

	public void addPlanToCourse(Course inCourse, TestPlan inPlan) {
		addPlanToCourse(inCourse, inPlan, null);
	}

	public void addPlanToCourse(Course inCourse, TestPlan inPlan, Integer ordering) {
		Searcher modactivities = getSearcher("moduleactivities");
		Data data = modactivities.query().exact("course", inCourse.getId()).exact("testplan", inPlan.getId())
				.searchOne();
		if (data == null) {
			data = modactivities.createNewData();
			data.setValue("course", inCourse.getId());
			data.setValue("testplan", inPlan.getId());

		}
		data.setValue("order", ordering);
		modactivities.saveData(data);
	}
	
	
	public void addActivityToGroup(LearningGroup inGroup, TestPlan inPlan) {
		Searcher modactivities = getSearcher("classactivities");
		Data data = modactivities.query().exact("learninggroup", inGroup.getId()).exact("testplan", inPlan.getId())
				.searchOne();
		if (data == null) {
			data = modactivities.createNewData();
			data.setValue("learninggroup", inGroup.getId());
			data.setValue("testplan", inPlan.getId());

		}
		modactivities.saveData(data);
	}
	
	
	

	public void addModuleToTemplate(Course inCourse, Data inTemplate) {

		addModuleToTemplate(inCourse, inTemplate, null);
	}

	public void addModuleToTemplate(Course inCourse, Data inTemplate, Integer ordering) {
		Searcher modactivities = getSearcher("classmodules");
		Data data = modactivities.query().exact("course", inCourse.getId()).exact("classtemplate", inTemplate.getId())
				.searchOne();
		if (data == null) {
			data = modactivities.createNewData();
			data.setValue("course", inCourse.getId());
			data.setValue("classtemplate", inTemplate.getId());

		}
		data.setValue("order", ordering);
		modactivities.saveData(data);
	}

	public Double getDefaultPassmark() {
		Double passmark = getDouble("passmark");
		if (passmark == null) {
			passmark = 0.7d;
		}
		return passmark;
	}

	public boolean canLaunchTest(WebPageRequest inReq, User inUser, TestPlan inPlan, Course inCourse) {
		Boolean permission = (Boolean) inReq.getPageValue("canviewplan-" + inPlan.getId());
		if (permission != null && !permission) {
			return false;
		}
		// #set($permissionvalue =
		// #if("$!permissionvalue" == "" || $permissionvalue == true)
		// #set($canattempt = true)
		// #end
		//
		// #set($passvalue = $context.getPageValue("canpass-${target.id}"))
		// #if( $passvalue == true)
		// #set($passed = true)
		// #end

		int index = inCourse.getTestPlans().indexOf(inPlan);
		if (index > 0) {
			TestPlan previous = (TestPlan) inCourse.getTestPlans().get(index - 1);
			if (!previous.hasPassed(inUser, this)) {
				return false;
			}
		}
		return true;
	}

	public boolean canLaunchCourse(WebPageRequest inReq, User inUser, LearningGroup inGroup, Course inCourse) {
		String path = getApplicationId() + "/classes/" + inGroup.getId() + "/courses/" + inCourse.getId() + "/";

		boolean cando = inReq.getPageStreamer().canDo("start", path);
		if (cando == false) {
			return false;
		}

		// #set($path =
		// "$apphome/classes/$lg.getId()/courses/$entry.getCourse().getId()/")
		// #if($pages.canDo("pass",$path))
		// #set($passed = true)
		// #else
		// #set($passed = false)
		//
		// #end
		// #if($pages.canDo("start",$path))
		// #set($start = true)
		// #else
		// #set($start = false)
		//
		// #end

		if (inGroup.useLaunchRules()) {
			int index = inGroup.getCourses().indexOf(inCourse);
			if (index > 0) {
				Course previous = (Course) inGroup.getCourses().get(index - 1);
				if (!previous.hasPassed(inReq, inGroup, inUser, this)) {
					return false;
				}
			}
		}
		return true;
	}

	public void fireLearningEvent(User inUser, String inVerb, Data inData, String inSearchType) {
		fireLearningEvent(null, inUser, inVerb, inData, inSearchType, null);
	}

	public void fireLearningEvent(WebPageRequest inReq, User inUser, String inVerb, Data inData, String inSearchType) {
		fireLearningEvent(inReq, inUser, inVerb, inData, inSearchType, null);
	}

	public void fireLearningEvent(WebPageRequest inReq, User inUser, String inVerb, Data inData, String inSearchType,
			Map inExtraDetails) {
		if (inReq != null) {
			String skipStatement = inReq.findValue("skipstatement");
			if (Boolean.parseBoolean(skipStatement)) {
				return;
			}
		}
		WebEvent event = new WebEvent();
		TinCanIDAssistant assistant = getTinCanAssistant();
		event.setSearchType(inSearchType);
		event.setUser(inUser);
		event.setOperation(inVerb);
		event.setSource(inData);
		event.setCatalogId(getCatalogId());
		if (inExtraDetails != null) {
			event.getMap().putAll(inExtraDetails);
		}
		if (inReq != null) {
			assistant.populateExtraData(inReq, event);
		}
		if (inData != null && event.getName() == null) {
			event.setName(inData.getName());
		}
		if (inData instanceof Test) {
			event.setProperty("testid", inData.getId());
			event.setProperty("learningGroup", inData.get("class"));
			event.setProperty("course", inData.get("course"));
			event.setProperty("testplan", inData.get("plan"));
		}
		getEventManager().fireEvent(event);

	}

	
	
	
	public String getYear() {
		Date now = new Date();
		SimpleDateFormat format = new SimpleDateFormat("yyyy");
		return format.format(now);
	}

	public String getTodaysDate() {
		Date now = new Date();
		SimpleDateFormat format = new SimpleDateFormat("dd/MM/yyyy");
		return format.format(now);
	}

	public String getFriendlyTimePeriod(Object inTimePeriod) {

		Long value = null;
		if (inTimePeriod == null) {
			return null;
		}

		if (inTimePeriod instanceof Long) {
			value = (Long) inTimePeriod;
		} else if (inTimePeriod instanceof String) {
			String timePeriod = (String) inTimePeriod;
			if (timePeriod.length() == 0) {
				return null;
			}

			try {
				value = Long.valueOf(timePeriod);
			} catch (NumberFormatException e) {
				e.printStackTrace();
				return "NaN: " + timePeriod;
			}
		} else if (inTimePeriod instanceof Integer) {
			value = new Long((int) inTimePeriod);
		}
		value = value * 1000;
		String friendly = DurationFormatUtils.formatDuration(value, "HH':'mm':'ss");
		return friendly;
	}

	public Data findResumableTest(String userid, String inTestPlan) {

		TestSearcher searcher = getTestSearcher();

		Data test = (Data) searcher.query().match("user", userid).match("plan", inTestPlan).not("status", "complete")
				.sort("dateDown").searchOne();
		return test;

	}
	
	
	public Data findExistingTest(String userid, String inTestPlan) {

		TestSearcher searcher = getTestSearcher();

		Data test = (Data) searcher.query().match("user", userid).match("plan", inTestPlan)
				.sort("dateDown").searchOne();
		return test;

	}
	
	

	public String getOriginalDownloadUrl(Asset inAsset) {
		MediaArchive archive = getMediaArchive();
		String url = "/" + archive.getMediaDbId() + "/services/module/asset/downloads/originals/"
				+ archive.asLinkToOriginal(inAsset);
		return url;

	}

	public String getOriginalDownloadUrl(String inId) {
		MediaArchive archive = getMediaArchive();
		Asset asset = archive.getAsset(inId);
		return getOriginalDownloadUrl(asset);
	}

	public int getRandom() {
		Random random = new Random();
		return random.nextInt(50);

	}

	public void getTestAnalysis(String inTestPlan, String inLearningGroup) {

	}

	public String getDifferenceFromNow(Date inDate) {
		long millis = System.currentTimeMillis() - inDate.getTime();
		Period period = new Period(0, 0, 0, (int) millis);
		PeriodFormatter formatter = new PeriodFormatterBuilder().appendYears().appendSuffix("y").appendMonths()
				.appendSuffix("m").appendWeeks().appendSuffix("w").appendDays().appendSuffix("d ").appendHours()
				.appendSuffix("h").appendMinutes().appendSuffix("m").appendSeconds().appendSuffix("s")

				.printZeroNever().toFormatter();

		String print = formatter.print(period);
		return print;

	}

	public Boolean isUserInClass(String inUserId, String inClassId) {
		if (inUserId == null) {
			return false;
		}
		Data row = getSearcher("studentclasses").query().exact("userprofile", inUserId)
				.exact("learninggroup", inClassId).searchOne();
		return row != null;
	}

	public HitTracker updateOnlineStatus(Integer seconds, String classid, String planid) {

		Searcher activityparticipanttracking = getSearcher("activityparticipanttracking");
		HitTracker participants = null;
		if (planid != null) {
			participants = activityparticipanttracking.query().exact("learninggroup", classid).exact("testplan", planid)
					.facet("onlinestatus").search();
		} else {
			participants = activityparticipanttracking.query().match("learninggroup", classid).facet("onlinestatus")
					.search();
		}

		for (Iterator iterator = participants.iterator(); iterator.hasNext();) {
			Data hit = (Data) iterator.next();
			Date lastonlinestatus = (Date) hit.getValue("lastonlinestatus");
			Date now = new Date();
			if (lastonlinestatus != null) {
				if (now.getTime() - lastonlinestatus.getTime() >= seconds * 1000) {// mark them offline after 20 sec
					Data real = (Data) activityparticipanttracking.searchById(hit.getId());
					real.setValue("lastonlinestatus", now);
					real.setValue("onlinestatus", "offline");
					activityparticipanttracking.saveData(real);
				}
			}
			if (lastonlinestatus == null) {
				Data real = (Data) activityparticipanttracking.searchById(hit.getId());
				real.setValue("lastonlinestatus", now);
				real.setValue("onlinestatus", "offline");
				activityparticipanttracking.saveData(real);
			}

		}
		return participants;
	}

	public int getActiveUserCount(String inClassId, String inActivityId) {
		// Searcher activityparticipanttracking =
		// getSearcher("activityparticipanttracking");
		// HitTracker participants =
		// activityparticipanttracking.query().match("learninggroup",
		// inClassId).exact("classmember", "true").exact("testplan",
		// inActivityId).exact("onlinestatus", "online").search();
		// return participants.size();
		return getBenchServer().getConnectedUsers().size();

	}

	public int getActiveUserCount(String inClassId) {
		// Searcher activityparticipanttracking =
		// getSearcher("activityparticipanttracking");
		// HitTracker participants =
		// activityparticipanttracking.query().match("learninggroup",
		// inClassId).exact("classmember", "true").exact("onlinestatus",
		// "online").missing("testplan").search();
		//
		// return participants.size();
		return getBenchServer().getConnectedUsers().size();
	}

	public int getOfflineUserCount(String inClassId) {
		Searcher classlist = getSearcherManager().getSearcher(getCatalogId(), "studentclasses");
		HitTracker studentlist = classlist.query().match("learninggroup", inClassId).not("grouprole", "instructor")
				.search();
		int activecount = getActiveUserCount(inClassId);
		return studentlist.size() - activecount;
	}

	public boolean isOnline(String inClassId, String inUserid) {
		// Searcher activityparticipanttracking =
		// getSearcher("activityparticipanttracking");
		//
		// Data results = activityparticipanttracking.query().match("learninggroup",
		// inClassId).exact("classmember", "true").exact("onlinestatus",
		// "online").missing("testplan").exact("user", inUserid).searchOne();
		// return results != null;
		return getBenchServer().isUserConnected(inUserid);

	}

	public boolean isDialedIn(String inClassId, String inUserid) {
		// Searcher activityparticipanttracking =
		// getSearcher("activityparticipanttracking");
		//
		// Data results = activityparticipanttracking.query().match("learninggroup",
		// inClassId).exact("classmember", "true").exact("onlinestatus",
		// "online").missing("testplan").exact("user", inUserid).searchOne();
		// return results != null;
		return getTwilioManager().isUserConnected(inUserid);

	}

	public int getOnlineProxyCount(String inClassId) {
		Searcher classlist = getSearcherManager().getSearcher(getCatalogId(), "studentclasses");
		HitTracker studentlist = classlist.query().match("learninggroup", inClassId).not("grouprole", "instructor")
				.search();
		int totalonlineproxies = 0;
		for (Iterator iterator = studentlist.iterator(); iterator.hasNext();) {
			Data participantinfo = (Data) iterator.next();
			if (isOnline(inClassId, participantinfo.get("userprofile"))) {
				try {
					int proxies = Integer.parseInt(participantinfo.get("proxycount"));
					totalonlineproxies += proxies;

				} catch (Exception e) {
					log.info("no proxies");
				}
			}
		}
		return totalonlineproxies;
	}

	public int getOnlineProxyCount(String inClassId, String inVoteClass) {
		Searcher classlist = getSearcherManager().getSearcher(getCatalogId(), "studentclasses");
		Searcher voteclass = getSearcherManager().getSearcher(getCatalogId(), "uservoteclass");

		HitTracker studentlist = classlist.query().match("learninggroup", inClassId).not("grouprole", "instructor")
				.search();
		int totalonlineproxies = 0;
		for (Iterator iterator = studentlist.iterator(); iterator.hasNext();) {
			Data participantinfo = (Data) iterator.next();
			if (isOnline(inClassId, participantinfo.get("userprofile"))) {
				try {
					BaseData foruser = (BaseData) voteclass.query().exact("voteclass", inVoteClass)
							.exact("userid", participantinfo.get("userprofile")).searchOne();
					if (foruser != null) {
						totalonlineproxies += foruser.getInt("proxycount");
					}

				} catch (Exception e) {
					log.info("no proxies");
				}
			}
		}
		return totalonlineproxies;
	}

	public TestManager getTestManager() {
		return getTestSearcher().getTestManager();
	}

	public List loadUserIds(String inGroup) {

		ArrayList ids = new ArrayList();
		Searcher searcher = getSearcher("studentclasses");
		HitTracker list = searcher.query().match("learninggroup", inGroup).search();
		for (Iterator iterator = list.iterator(); iterator.hasNext();) {
			Data hit = (Data) iterator.next();
			String id = hit.get("userprofile");
			ids.add(id);
		}
		return ids;

	}

	public LiveTestManager getLiveTestManager() {
		return (LiveTestManager) getModuleManager().getBean(getCatalogId(), "liveTestManager");
	}

	public void addCourseToGroup(Course inCourse, LearningGroup inGroup, int order) {
		Searcher modactivities = getSearcher("classmodules");
		Data data = modactivities.query().exact("course", inCourse.getId()).exact("learninggroup", inGroup.getId())
				.searchOne();
		if (data == null) {
			data = modactivities.createNewData();
			data.setValue("course", inCourse.getId());
			data.setValue("learninggroup", inGroup.getId());

		}
		data.setValue("order", order);
		modactivities.saveData(data);

	}

	public void addCourseToGroup(Course inCourse, LearningGroup inGroup) {
		Searcher modactivities = getSearcher("classmodules");
		Data data = modactivities.query().exact("course", inCourse.getId()).exact("learninggroup", inGroup.getId())
				.searchOne();
		if (data == null) {
			data = modactivities.createNewData();
			data.setValue("course", inCourse.getId());
			data.setValue("learninggroup", inGroup.getId());

		}
		data.setValue("order", inGroup.getCourses().size());
		modactivities.saveData(data);

	}

	public void setStartTime(WebPageRequest inReq) {
		inReq.putSessionValue("starttime", new Date());
	}

	public long getElapsedSeconds(WebPageRequest inReq) {

		Date start = (Date) inReq.getSessionValue("starttime");
		if (start == null) {
			setStartTime(inReq);
			start = new Date();
		}

		Date now = new Date();
		long seconds = (now.getTime() - start.getTime()) / 1000;
		return seconds;
	}

	public User getUserByPhone(String inKey, String inValue)

	{
		for (Iterator iterator = getUserManager().getUsers().iterator(); iterator.hasNext();) {
			Data user = (Data) iterator.next();
			String phone = user.get(inKey);
			if (phone == null) {
				continue;
			}
			phone = phone.replaceAll("[^0-9]", "");
			inValue = inValue.replaceAll("[^0-9]", "");
			if (inValue.equals(phone)) {
				return getUserManager().getUser(user.getId());
			}
		}
		return null;
	}

	public ConversionBuilder conversion() {
		return (ConversionBuilder) getModuleManager().getBean("conversionBuilder");
	}

	public void validateProfile(String inId) {
		User user = getUserManager().getUser(inId);
		Searcher userprofiles = getSearcher("userprofile");
		if (user != null) {
			UserProfile profile = (UserProfile) userprofiles.searchById(inId);
			boolean needssave = false;

			if (profile == null) {
				profile = (UserProfile) userprofiles.createNewData();
				profile.setId(inId);
				needssave = true;
			}

			for (Iterator iterator = user.getProperties().keySet().iterator(); iterator.hasNext();) {
				String key = (String) iterator.next();
				if ("emrecordstatus".equals(key)) {
					continue;
				}
				String keys[] = { "firstName", "lastName", "firstname", "lastname", "email" };
				Collection keylist = Arrays.asList(keys);
				String val = user.get(key);
				if (keylist.contains(key)) {

					if (profile.get(key) == null) {
						profile.setValue(key, val);
						needssave = true;
					}
				}
			}
			if (needssave) {
				userprofiles.saveData(profile);
			}

		}
	}

	public String getEnterMediaKey(User user) {
		String tempkey = getUserManager().getStringEncryption().getEnterMediaKey(user);
		return tempkey;
	}

	public LiveStreamManager getLiveStreamManager() {
		LiveStreamManager bean = (LiveStreamManager) getBean("liveStreamManager");
		return bean;
	}

	public Asset createAsset(Page inItem, HashMap inVals, User inUser, String inSourcepath) {
		MediaArchive archive = getMediaArchive();
		AssetSearcher searcher = archive.getAssetSearcher();
		SearcherManager sm = archive.getSearcherManager();

		AssetImporter importer = archive.getAssetImporter();

		Asset asset = null;

		String id = null;

		if (inSourcepath == null) {
			inVals.put("filename", inItem.getName());
			String ext = PathUtilities.extractPageType(inItem.getName());
			String render = archive.getMediaRenderType(ext);
			inVals.put("extension", ext);
			inVals.put("rendertype", render);

			String guid = UUID.randomUUID().toString();
			String sguid = guid.substring(0, Math.min(guid.length(), 13));
			inVals.put("guid", sguid);
			inVals.put("splitguid", sguid.substring(0, 2) + "/" + sguid.substring(3).replace("-", ""));

			String df = DateStorageUtil.getStorageUtil().formatDateObj(new Date(), "yyyyMM");// new
																								// SimpleDateFormat("yyyyMM");

			inVals.put("formatteddate", df);

			df = DateStorageUtil.getStorageUtil().formatDateObj(new Date(), "yyyy/MM");
			inVals.put("formattedmonth", df);

			String importpath = (String) inVals.get("importpath");
			if (importpath != null) {
				String filename = PathUtilities.extractFileName(importpath);
				inVals.put("filename", filename);
			}

			inSourcepath = (String) inVals.get("sourcepath");

			if (inSourcepath == null) {
				inSourcepath = archive.getCatalogSettingValue("catalogassetupload"); // ${division.uploadpath}/${user.userName}/${formateddate}
			}
			if (inSourcepath == null || inSourcepath.length() == 0) {
				inSourcepath = "receivedfiles/${id}";
			}
			inSourcepath = sm.getValue(archive.getCatalogId(), inSourcepath, inVals); // This does some fancy replacing
																						// with
																						// Ids
		}
		String path = "/WEB-INF/data/" + archive.getCatalogId() + "/originals/" + inSourcepath + "/" + inItem.getName();
		path = path.replace("//", "/");

		Page newfile = archive.getPageManager().getPage(path);
		// THis will append the filename to the source path
		archive.getPageManager().movePage(inItem, newfile);
		asset = importer.createAssetFromPage(archive, false, inUser, newfile, id);

		importer.saveAsset(archive, inUser, asset);
		return asset;

	}

	public boolean isMuted(String inId) {
		return getTwilioManager().isMuted(inId);
	}

	public String getYoutubeId(String inUrl) {
		String vId = null;
	    Pattern pattern = Pattern.compile(
	                     "^https?://.*(?:youtu.be/|v/|u/\\w/|embed/|watch?v=)([^#&?]*).*$", 
	                     Pattern.CASE_INSENSITIVE);
	    Matcher matcher = pattern.matcher(inUrl);
	    if (matcher.matches()){
	        vId = matcher.group(1);
	    }
	    return vId;

	}

	
	public org.entermediadb.asset.Category createPodFolder(String inId){
		LearningGroup group = getLearningGroup(inId);
		return createPodFolder(group);
	}

	public org.entermediadb.asset.Category  createPodFolder( LearningGroup group) {
		MediaArchive mediaArchive = getMediaArchive();
		org.entermediadb.asset.Category parents = mediaArchive.createCategoryPath("Pods");
		String categoryid = group.getId() + "podassets";
		org.entermediadb.asset.Category  category = mediaArchive.getCategory(categoryid);
		if (category == null)
		{
			category = (org.entermediadb.asset.Category) mediaArchive.getCategorySearcher().createNewData();
			category.setId(categoryid);
			category.setParentCategory(parents);
			category.setName(group.getName());
			mediaArchive.getCategorySearcher().saveCategory(category);

		}
		return category;
	}
	
	private String getYouTubeId (String youTubeUrl) {
	    String pattern = "(?<=youtu.be/|watch\\?v=|/videos/|embed\\/)[^#\\&\\?]*";
	    Pattern compiledPattern = Pattern.compile(pattern);
	    Matcher matcher = compiledPattern.matcher(youTubeUrl);
	    if(matcher.find()){
	        return matcher.group();
	    } else {
	        return "error";  
	    }
	}
	
	public  String extractYoutubeId(String ytUrl) {
		  Matcher youtube = YOUTUBE_PATTERN.matcher(ytUrl);
	        if (!youtube.find())
	            return null;

	        String group = youtube.group(1);

	        return group;
	}
	
	 // regular expressions
    private  final Pattern YOUTUBE_PATTERN = Pattern.compile(".*(?:youtu.be\\/|v\\/|u\\/\\w\\/|embed\\/|watch\\?v=)([^#\\&\\?]*).*", Pattern.CASE_INSENSITIVE);
    private static final Pattern VIMEO_PATTERN = Pattern.compile("[http|https]+:\\/\\/(?:www\\.|)vimeo\\.com\\/([a-zA-Z0-9_\\-]+)(&.+)?", Pattern.CASE_INSENSITIVE);
    
    // youtube thumbnail settings
    private  final String YOUTUBE_THUMBNAIL_URL = "//i.ytimg.com/vi/";
    private  final String YOUTUBE_THUMBNAIL_SIZE = "/hqdefault.jpg";

    public  boolean isYouTubeUrl(String url) {
        return YOUTUBE_PATTERN.matcher(url).matches();
    }

    public  boolean isVimeoUrl(String url) {
        return VIMEO_PATTERN.matcher(url).matches();
    }

    public  String getYouTubeThumbnailUrl( String url) {
        Matcher youtube = YOUTUBE_PATTERN.matcher(url);
        if (!youtube.find())
            return null;

        String group = youtube.group(1);

        return YOUTUBE_THUMBNAIL_URL + group + YOUTUBE_THUMBNAIL_SIZE;
    }

    public  long getVimeoVideoId( String url) {
        Matcher vimeo = VIMEO_PATTERN.matcher(url);
        if (!vimeo.find())
            return -1;

        return Long.valueOf(vimeo.group(1));
    }

	public String scrapeTitle(String inUrl) {
		 try {
			 Document doc = Jsoup.connect(inUrl).get();
			 return doc.title();
		} catch (Exception e) {
			log.info("inUrl had no title" + inUrl);
		}
		 return null;
	}
	
	
	
}