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.db.DBBook;
import de.mpiwg.gazetteer.db.DBSectionVersion;
import de.mpiwg.gazetteer.utils.DBService;
import de.mpiwg.web.books.SortBooksByAdminType;
import de.mpiwg.web.books.SortBooksByBookId;
import de.mpiwg.web.books.SortBooksByDate;
import de.mpiwg.web.books.SortBooksByDynasty;
import de.mpiwg.web.books.SortBooksByEdition;
import de.mpiwg.web.books.SortBooksByEditor;
import de.mpiwg.web.books.SortBooksByLevel1;
import de.mpiwg.web.books.SortBooksByLevel2;
import de.mpiwg.web.books.SortBooksByName;
import de.mpiwg.web.books.SortBooksByPeriod;
import de.mpiwg.web.books.SortBooksByStartYear;
import de.mpiwg.web.books.SortBooksByTocCorrection;

public class BooksPage extends AbstractJSPPage{

	private static Logger logger = Logger.getLogger(BooksPage.class);
	
	public static String bean = "booksBean";
	public static String page = "pages/books.jsp";
	private List<DBBook> completeBookList;
	
	private List<DBBook> filteredBookList;
	private List<DBBook> displayBookList;

	private Map<String, DBSectionVersion> sectionVersionMap = null;
	private int bookNumber;

	private String tocBookId = new String();
	
	private String bookNameFilter = new String();
	private String dynastyFilter = new String();
	private String adminTypeFilter = new String();
	private String level1Filter = new String();
	private String level2Filter = new String();
	private String periodFilter = new String();
	private String editionFilter = new String();
	

	public void loadParameters(HttpServletRequest request, HttpServletResponse response){
		this.request = request;
		this.response = response;
		
		this.tocBookId = getParameter("tocBookId");

		this.bookNameFilter = getParameter("bookNameFilter");
		this.dynastyFilter = getParameter("dynastyFilter");
		this.adminTypeFilter = getParameter("adminTypeFilter");
		this.level1Filter = getParameter("level1Filter");
		this.level2Filter = getParameter("level2Filter");
		this.periodFilter = getParameter("periodFilter");
		this.editionFilter = getParameter("editionFilter");
		
	}
	
	

	public void filter(){
		
		this.filteredBookList = new ArrayList<DBBook>();
		for(DBBook book : this.completeBookList){
			if(!this.filteredBookList.contains(book)){
				
				if( (StringUtils.isEmpty(dynastyFilter) || StringUtils.startsWith(book.getDynasty(), dynastyFilter)) &&
						(StringUtils.isEmpty(level1Filter) || StringUtils.startsWith(book.getLevel1(), level1Filter)) &&
						(StringUtils.isEmpty(level2Filter) || StringUtils.startsWith(book.getLevel2(), level2Filter)) &&
						(StringUtils.isEmpty(periodFilter) || StringUtils.startsWith(book.getPeriod(), periodFilter)) &&
						(StringUtils.isEmpty(editionFilter) || StringUtils.startsWith(book.getEdition(), editionFilter)) &&
						(StringUtils.isEmpty(bookNameFilter) || StringUtils.startsWith(book.getName(), bookNameFilter)) &&
						(StringUtils.isEmpty(adminTypeFilter) || StringUtils.startsWith(book.getAdmin_type(), adminTypeFilter))
								){
					this.filteredBookList.add(book);
					
				}	
			}
		}
		
		if(completeBookList.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.updateCurrentBooks();
		}else{
			//this.searchMessage = "No sections found for the term(s): " + this.searchTerm;
			this.filteredBookList = null;
		}
		
	}
	
	
	private void updateCurrentBooks() {
		this.displayBookList = this.filteredBookList;
		/*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()));
		}
		*/
	}
	

	public List<DBBook> getDisplayBookList() {
		return displayBookList;
	}



	public void setDisplayBookList(List<DBBook> displayBookList) {
		this.displayBookList = displayBookList;
	}

	
	public String getDynastyFilter() {
		return dynastyFilter;
	}


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


	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;
	}

	
	public String getTocBookId() {
		return tocBookId;
	}

	public void setTocBookId(String tocBookId) {
		this.tocBookId = tocBookId;
	}

	public int getBookNumber() {
		return bookNumber;
	}

	public void setBookNumber(int bookNumber) {
		this.bookNumber = bookNumber;
	}

	
	public List<DBBook> getCompleteBookList() {
		return completeBookList;
	}

	public void loadBooks(){
		if(this.completeBookList == null){
			this.forceLoadBooks();
			filter();
		} 
		
	}
	
	public void forceLoadBooks(){
		logger.debug("loadBooks");

		this.loadSectionsVersion();
		
		this.completeBookList = new ArrayList<DBBook>();
		if(getSessionBean().getUser() != null){
			logger.debug("loading book list");
			// === load book table from db ==
			
			for(DBBook book : DBService.getInstance().getBooks()){		
				// set editor and date (current version)
				book.setCurrentSectionVersion(sectionVersionMap.get(book.getId()));
				
				this.completeBookList.add(book);
			}	
			
			this.setBookNumber(this.completeBookList.size());
			
		}
		
	}
	
	private void loadSectionsVersion(){
		this.sectionVersionMap = new HashMap<String, DBSectionVersion>();
		
		try {
			for(DBSectionVersion sv : DBService.getInstance().getSectionVersionList()){
				this.sectionVersionMap.put(sv.getBooks_id(), sv);
			}	
		} catch (Exception e) {
			addMsg("There is an internal error: " + e.getLocalizedMessage());
			e.printStackTrace();
		}
		
		
	}

	public void setTocCorrection() {
		String tocBookId = this.getTocBookId();		
		logger.debug("tocFinishedBookId=" + tocBookId);
		try {
			DBService.getInstance().updateTocCorrection(tocBookId, 1);
		}catch (Exception e) {
			addMsg("There is an internal error: " + e.getLocalizedMessage());
			e.printStackTrace();
		} 
	
		//logger.debug("toc_correction:"+DBService.getInstance().getBook(tocBookId).getToc_correction());
		
	}


	public void unSetTocCorrection() {
		String tocBookId = this.getTocBookId();
		logger.debug("tocFinishedBookId=" + tocBookId);
		try {
			DBService.getInstance().updateTocCorrection(tocBookId, 0);
		}catch (Exception e) {
			addMsg("There is an internal error: " + e.getLocalizedMessage());
			e.printStackTrace();
		}
		
		
	}

	public void sortByBookIdUp() {
		Collections.sort(this.completeBookList, new SortBooksByBookId());
		filter();
	}

	public void sortByBookIdDown() {
		Collections.sort(this.completeBookList, new SortBooksByBookId());
		Collections.reverse(completeBookList);
		filter();
	}

	public void sortByBookNameUp(){
		Collections.sort(this.completeBookList, new SortBooksByName());
		filter();
	}
	
	public void sortByBookNameDown(){
		Collections.sort(this.completeBookList, new SortBooksByName());
		Collections.reverse(completeBookList);
		filter();
	}
	
	public void sortByLevel1Up(){
		Collections.sort(this.completeBookList, new SortBooksByLevel1());
		filter();
	}
	
	public void sortByLevel1Down(){
		Collections.sort(this.completeBookList, new SortBooksByLevel1());
		Collections.reverse(completeBookList);
		filter();
	}
	public void sortByLevel2Up(){
		Collections.sort(this.completeBookList, new SortBooksByLevel2());
		filter();
	}
	
	public void sortByLevel2Down(){
		Collections.sort(this.completeBookList, new SortBooksByLevel2());
		Collections.reverse(completeBookList);
		filter();
	}
	
	public void sortByPeriodUp(){
		Collections.sort(this.completeBookList, new SortBooksByPeriod());
		filter();
	}
	
	public void sortByPeriodDown(){
		Collections.sort(this.completeBookList, new SortBooksByPeriod());
		Collections.reverse(completeBookList);
		filter();
	}
	
	public void sortByAdminTypeUp(){
		Collections.sort(this.completeBookList, new SortBooksByAdminType());
		filter();
	}
	
	public void sortByAdminTypeDown(){
		Collections.sort(this.completeBookList, new SortBooksByAdminType());
		Collections.reverse(completeBookList);
		filter();
	}
	
	public void sortByStartYearUp(){
		Collections.sort(this.completeBookList, new SortBooksByStartYear());
		filter();
	}
	
	public void sortByStartYearDown(){
		Collections.sort(this.completeBookList, new SortBooksByStartYear());
		Collections.reverse(completeBookList);
		filter();
	}
	
	public void sortByDynastyUp(){
		Collections.sort(this.completeBookList, new SortBooksByDynasty());
		filter();
	}
	
	public void sortByDynastyDown(){
		Collections.sort(this.completeBookList, new SortBooksByDynasty());
		Collections.reverse(completeBookList);
		filter();
	}
	public void sortByEditionUp(){
		Collections.sort(this.completeBookList, new SortBooksByEdition());
		filter();
	}
	
	public void sortByEditionDown(){
		Collections.sort(this.completeBookList, new SortBooksByEdition());
		Collections.reverse(completeBookList);
		filter();
	}

	
	
	public void sortByEditorUp(){
		Collections.sort(this.completeBookList, new SortBooksByEditor());
		filter();
	}
	
	public void sortByEditorDown(){
		Collections.sort(this.completeBookList, new SortBooksByEditor());
		Collections.reverse(completeBookList);
		filter();
	}
	
	public void sortByDateUp(){
		Collections.sort(this.completeBookList, new SortBooksByDate());
		filter();
	}
	
	public void sortByDateDown(){
		Collections.sort(this.completeBookList, new SortBooksByDate());
		Collections.reverse(completeBookList);
		filter();
	}

	public void sortByTocCorrectionUp(){
		Collections.sort(this.completeBookList, new SortBooksByTocCorrection());
		filter();
	}
	
	public void sortByTocCorrectionDown(){
		Collections.sort(this.completeBookList, new SortBooksByTocCorrection());
		Collections.reverse(completeBookList);
		filter();
	}
	
	public String getBookNameFilter() {
		return bookNameFilter;
	}



	public void setBookNameFilter(String bookNameFilter) {
		this.bookNameFilter = bookNameFilter;
	}



	public String getLevel2Filter() {
		return level2Filter;
	}



	public void setLevel2Filter(String level2Filter) {
		this.level2Filter = level2Filter;
	}



	public String getPeriodFilter() {
		return periodFilter;
	}



	public void setPeriodFilter(String periodFilter) {
		this.periodFilter = periodFilter;
	}



	public String getEditionFilter() {
		return editionFilter;
	}



	public void setEditionFilter(String editionFilter) {
		this.editionFilter = editionFilter;
	}




	
}