package de.mpiwg.web.jsp;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import de.mpiwg.gazetteer.bo.LGBranch;
import de.mpiwg.gazetteer.db.DBSection;
import de.mpiwg.gazetteer.utils.DBService;
import de.mpiwg.gazetteer.utils.DataProvider;
import de.mpiwg.web.search.SortSectionByAdminType;
import de.mpiwg.web.search.SortSectionByAuthor;
import de.mpiwg.web.search.SortSectionByBookId;
import de.mpiwg.web.search.SortSectionByBookName;
import de.mpiwg.web.search.SortSectionByDynasty;
import de.mpiwg.web.search.SortSectionByEdition;
import de.mpiwg.web.search.SortSectionById;
import de.mpiwg.web.search.SortSectionByLevel1;
import de.mpiwg.web.search.SortSectionByPeriod;
import de.mpiwg.web.search.SortSectionByStartPage;
import de.mpiwg.web.search.SortSectionByVolume;

public class SearchPage extends AbstractJSPPage{
	
	private static Logger logger = Logger.getLogger(SearchPage.class);
	
	public static String bean = "searchBean";
	public static String page = "pages/search.jsp";
	
	private static Integer SEARCH_IN_SECTION_NAME = 0;
	private static Integer SEARCH_IN_BOOK_NAME = 1;
	private static Integer SEARCH_FULL_TEXT = 2;
	
	
	
	private Map<Long, List<LGBranch>> branchesMap;
	private List<DBSection> completeSectionList;
	private List<DBSection> filteredSectionList;
	private List<DBSection> displaySectionList;
	
	private String searchTerm = new String();
	private Integer searchIn = SEARCH_IN_SECTION_NAME;
	
	private String dynastyFilter = new String();
	private String adminTypeFilter = new String();
	private String level1Filter = new String();
	
	private DataPaginator paginator = new DataPaginator();
	private String searchMessage;
	private String filteringMessage;
	
	@Override
	public void init(){
		super.init();
	}
	
	public void loadParameters(HttpServletRequest request, HttpServletResponse response){
		this.request = request;
		this.response = response;
		
		this.searchTerm = getParameter("searchTerm");
		this.dynastyFilter = getParameter("dynastyFilter");
		this.adminTypeFilter = getParameter("adminTypeFilter");
		this.level1Filter = getParameter("level1Filter");
		this.searchIn = getIntParameter("searchIn");
	}
	
	public void search(){
		logger.debug("Searching: " + this.searchTerm);
		
		this.dynastyFilter = new String();
		this.level1Filter = new String();
		this.adminTypeFilter = new String();
		
		if(StringUtils.isNotEmpty(this.searchTerm)){
			this.loadBranches();
			try {
				List<String> terms = splitTerms();
				
				if(SEARCH_IN_SECTION_NAME.equals(this.searchIn)){
					System.out.println("Search in Section Name");
					this.completeSectionList = DBService.searchSection(terms);
				}else if(SEARCH_IN_BOOK_NAME.equals(this.searchIn)){
					System.out.println("Search in Book Name");
					this.completeSectionList = DBService.searchBook(terms, "name");
				}/*else if(SEARCH_FULL_TEXT.equals(this.searchIn)){
					System.out.println("Search Full Text");
					DBService.searchFullText(terms);
				}*/
				
				Collections.sort(this.completeSectionList);
				
				filter();

								
			} catch (Exception e) {
				internalError(e);
			}			
		}
	}
	
	public void filter(){
		this.filteredSectionList = new ArrayList<DBSection>();
		for(DBSection section : this.completeSectionList){
			if(!this.filteredSectionList.contains(section)){
				
				if( (StringUtils.isEmpty(dynastyFilter) || StringUtils.startsWith(section.getBook().getDynasty(), dynastyFilter)) &&
						(StringUtils.isEmpty(level1Filter) || StringUtils.startsWith(section.getBook().getLevel1(), level1Filter)) &&
						(StringUtils.isEmpty(adminTypeFilter) || StringUtils.startsWith(section.getBook().getAdmin_type(), adminTypeFilter))
								){
					this.filteredSectionList.add(section);
				}	
			}
		}
		
		if(completeSectionList.size() > 0){
			this.searchMessage = completeSectionList.size() + " section(s) found for the term(s): " + this.searchTerm;
			this.filteringMessage = this.filteredSectionList.size() + " section(s) listed after the filtering";
			this.paginator.setCurrentPage(0);
			this.paginator.resetNumberOfPages(filteredSectionList.size());
			this.updateCurrentSections();
		}else{
			this.searchMessage = "No sections found for the term(s): " + this.searchTerm;
			this.filteredSectionList = null;
		}
	}
	
	private void updateCurrentSections() {
		this.paginator.initCount();
		int startRecord = this.paginator.getCurrentPage()
				* this.paginator.getItemsPerPage();
		if(this.paginator.getNumberOfPages() == 0){
			this.displaySectionList = new ArrayList<DBSection>();
		}else if((this.paginator.getCurrentPage() + 1) == this.paginator.getNumberOfPages()){
			int mod = this.filteredSectionList.size() % paginator.getItemsPerPage();
			if(mod == 0){
				this.displaySectionList = filteredSectionList.subList(startRecord, startRecord + this.paginator.getItemsPerPage());
			}else{
				this.displaySectionList = filteredSectionList.subList(startRecord, startRecord + mod);	
			}
			
		}else{
			this.displaySectionList = filteredSectionList.subList(startRecord, startRecord + this.paginator.getItemsPerPage());	
		}
		
		for(DBSection section : this.displaySectionList){
			section.setBranches(this.branchesMap.get(section.getId()));
		}
	}
	
	private void loadBranches(){
		this.branchesMap = new HashMap<Long, List<LGBranch>>();
		List<LGBranch> list = DataProvider.getInstance().getBranches(getSessionBean().getUser().getId());
		for(LGBranch branch : list){
			branch.loadTransientData();
			if(this.branchesMap.get(branch.getSectionId()) == null){
				this.branchesMap.put(branch.getSectionId(), new ArrayList<LGBranch>());
			}
			this.branchesMap.get(branch.getSectionId()).add(branch);
		}
	}
	
	private List<String> splitTerms(){
		List<String> rs = new ArrayList<String>();
		String[] array = this.searchTerm.split(",");
		
		for(String tmp : array){
			tmp = tmp.replace(" ", "");
			if(StringUtils.isNotEmpty(tmp)){
				rs.add(tmp);	
			}
		}
		return rs;
	}

	public List<String> suggestDynasty(String term, int limit){
		List<String> list = new ArrayList<String>();
		for(DBSection section : this.completeSectionList){
			String dynasty = section.getBook().getDynasty();
			if(!list.contains(dynasty) && dynasty.startsWith(term)){
				list.add(dynasty);
			}
			if(limit == list.size()){
				break;
			}	
		}
		return list;
	}
	
	public List<String> suggestLevel1(String term, int limit){
		List<String> list = new ArrayList<String>();
		for(DBSection section : this.completeSectionList){
			String level1 = section.getBook().getLevel1();
			if(!list.contains(level1) && level1.startsWith(term)){
				list.add(level1);
			}
			if(limit == list.size()){
				break;
			}	
		}
		return list;
	}
	
	public List<String> suggestAdminType(String term, int limit){
		List<String> list = new ArrayList<String>();
		for(DBSection section : this.completeSectionList){
			String adminType = section.getBook().getAdmin_type();
			if(!list.contains(adminType) && adminType.startsWith(term)){
				list.add(adminType);
			}
			if(limit == list.size()){
				break;
			}	
		}
		return list;
	}
	

	public static Integer getSEARCH_IN_SECTION_NAME() {
		return SEARCH_IN_SECTION_NAME;
	}


	public static void setSEARCH_IN_SECTION_NAME(Integer sEARCH_IN_SECTION_NAME) {
		SEARCH_IN_SECTION_NAME = sEARCH_IN_SECTION_NAME;
	}


	public Map<Long, List<LGBranch>> getBranchesMap() {
		return branchesMap;
	}


	public void setBranchesMap(Map<Long, List<LGBranch>> branchesMap) {
		this.branchesMap = branchesMap;
	}


	public List<DBSection> getCompleteSectionList() {
		return completeSectionList;
	}


	public void setCompleteSectionList(List<DBSection> completeSectionList) {
		this.completeSectionList = completeSectionList;
	}


	public String getSearchTerm() {
		return searchTerm;
	}


	public void setSearchTerm(String searchTerm) {
		this.searchTerm = searchTerm;
	}


	public Integer getSearchIn() {
		return searchIn;
	}


	public void setSearchIn(Integer searchIn) {
		this.searchIn = searchIn;
	}

	public List<DBSection> getFilteredSectionList() {
		return filteredSectionList;
	}

	public void setFilteredSectionList(List<DBSection> filteredSectionList) {
		this.filteredSectionList = filteredSectionList;
	}

	public List<DBSection> getDisplaySectionList() {
		return displaySectionList;
	}

	public void setDisplaySectionList(List<DBSection> displaySectionList) {
		this.displaySectionList = displaySectionList;
	}

	public DataPaginator getPaginator() {
		return paginator;
	}

	public void setPaginator(DataPaginator paginator) {
		this.paginator = paginator;
	}
	
	public void firstPage() {
		this.paginator.first();
		this.updateCurrentSections();
	}

	public void lastPage() {
		this.paginator.last();
		this.updateCurrentSections();
	}

	public void fastForward() {
		this.paginator.fastForward();
		this.updateCurrentSections();
	}

	public void fastRewind() {
		this.paginator.fastRewind();
		this.updateCurrentSections();
	}

	public void previousPage() {
		this.paginator.previous();
		this.updateCurrentSections();
	}

	public void nextPage() {
		this.paginator.next();
		this.updateCurrentSections();
	}

	public String getSearchMessage() {
		return searchMessage;
	}

	public void setSearchMessage(String searchMessage) {
		this.searchMessage = searchMessage;
	}

	public String getFilteringMessage() {
		return filteringMessage;
	}

	public void setFilteringMessage(String filteringMessage) {
		this.filteringMessage = filteringMessage;
	}
	
	/////// Sorting
	
	public String getDynastyFilter() {
		return dynastyFilter;
	}

	public void setDynastyFilter(String dynastyFilter) {
		this.dynastyFilter = dynastyFilter;
	}

	public void sortByBookNameUp(){
		Collections.sort(this.completeSectionList, new SortSectionByBookName());
		filter();
	}
	
	public void sortByBookNameDown(){
		Collections.sort(this.completeSectionList, new SortSectionByBookName());
		Collections.reverse(this.completeSectionList);
		filter();
	}
	
	public void sortBySectionNameUp(){
		Collections.sort(this.completeSectionList);
		filter();
	}
	
	public void sortBySectionNameDown(){
		Collections.sort(this.completeSectionList);
		Collections.reverse(this.completeSectionList);
		filter();
	}
	
	public void sortByAuthorUp(){
		Collections.sort(this.completeSectionList, new SortSectionByAuthor());
		filter();
	}
	
	public void sortByAuthorDown(){
		Collections.sort(this.completeSectionList, new SortSectionByAuthor());
		Collections.reverse(this.completeSectionList);
		filter();
	}
	
	public void sortByPeriodUp(){
		Collections.sort(this.completeSectionList, new SortSectionByPeriod());
		filter();
	}
	
	public void sortByPeriodDown(){
		Collections.sort(this.completeSectionList, new SortSectionByPeriod());
		Collections.reverse(this.completeSectionList);
		filter();
	}
	
	public void sortByVolumeUp(){
		Collections.sort(this.completeSectionList, new SortSectionByVolume());
		filter();
	}
	
	public void sortByVolumeDown(){
		Collections.sort(this.completeSectionList, new SortSectionByVolume());
		Collections.reverse(this.completeSectionList);
		filter();
	}
	
	
	public void sortBySectionIdUp(){
		Collections.sort(this.completeSectionList, new SortSectionById());
		this.filter();
	}
	
	public void sortBySectionIdDown(){
		Collections.sort(this.completeSectionList, new SortSectionById());
		Collections.reverse(completeSectionList);
		this.filter();
	}
	
	public void sortByEditionUp(){
		Collections.sort(this.completeSectionList, new SortSectionByEdition());
		filter();
	}
	
	public void sortByEditionDown(){
		Collections.sort(this.completeSectionList, new SortSectionByEdition());
		Collections.reverse(completeSectionList);
		filter();
	}
	
	public void sortByDynastyUp(){
		Collections.sort(this.completeSectionList, new SortSectionByDynasty());
		filter();
	}
	
	public void sortByDynastyDown(){
		Collections.sort(this.completeSectionList, new SortSectionByDynasty());
		Collections.reverse(completeSectionList);
		filter();
	}
	
	public void sortByBookIdUp(){
		Collections.sort(this.completeSectionList, new SortSectionByBookId());
		filter();
	}
	
	public void sortByBookIdDown(){
		Collections.sort(this.completeSectionList, new SortSectionByBookId());
		Collections.reverse(completeSectionList);
		filter();
	}
	
	public void sortByLevel1Up(){
		Collections.sort(this.completeSectionList, new SortSectionByLevel1());
		filter();
	}
	
	public void sortByLevel1Down(){
		Collections.sort(this.completeSectionList, new SortSectionByLevel1());
		Collections.reverse(completeSectionList);
		filter();
	}
	
	public void sortByAdminTypeUp(){
		Collections.sort(this.completeSectionList, new SortSectionByAdminType());
		filter();
	}
	
	public void sortByAdminTypeDown(){
		Collections.sort(this.completeSectionList, new SortSectionByAdminType());
		Collections.reverse(completeSectionList);
		filter();
	}
	
	public void sortByStartPageUp(){
		Collections.sort(this.completeSectionList, new SortSectionByStartPage());
		filter();
	}
	
	public void sortByStartPageDown(){
		Collections.sort(this.completeSectionList, new SortSectionByStartPage());
		Collections.reverse(completeSectionList);
		filter();
	}

	public String getAdminTypeFilter() {
		return adminTypeFilter;
	}

	public void setAdminTypeFilter(String adminTypeFilter) {
		this.adminTypeFilter = adminTypeFilter;
	}

	public String getLevel1Filter() {
		return level1Filter;
	}

	public void setLevel1Filter(String level1Filter) {
		this.level1Filter = level1Filter;
	}
	
	
}