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 DataPaginator paginator = new DataPaginator();


	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();
	private String lastEditorFilter = new String();
	private String editTimeFilter = new String();
	private String yearFilter = new String();
	private String sourceFilter = new String();




	private String filteringMessage;


	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");
		this.lastEditorFilter = getParameter("lastEditorFilter");
		this.editTimeFilter = getParameter("editTimeFilter");
		this.yearFilter = getParameter("yearFilter");
		this.sourceFilter = getParameter("sourceFilter");

	}



	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.contains(book.getLevel1(), level1Filter)) &&
					(StringUtils.isEmpty(level2Filter) || StringUtils.contains(book.getLevel2(), level2Filter)) &&
					(StringUtils.isEmpty(periodFilter) || StringUtils.contains(book.getPeriod(), periodFilter)) &&
					(StringUtils.isEmpty(editionFilter) || StringUtils.contains(book.getEdition(), editionFilter)) &&
					(StringUtils.isEmpty(bookNameFilter) || StringUtils.contains(book.getName(), bookNameFilter)) &&
					(StringUtils.isEmpty(dynastyFilter) || StringUtils.contains(book.getDynasty(), dynastyFilter)) &&
					(StringUtils.isEmpty(adminTypeFilter) || StringUtils.contains(book.getAdmin_type(), adminTypeFilter)) &&
          (StringUtils.isEmpty(yearFilter) || StringUtils.contains(book.getYear(), yearFilter)) &&
					(StringUtils.isEmpty(sourceFilter) || StringUtils.contains(book.getSource(), sourceFilter))
					){
						String lastEditor = new String();
						String editTime = new String();
						if ( book.getCurrentSectionVersion() != null) {
							lastEditor = book.getCurrentSectionVersion().getEditor();
							editTime = book.getCurrentSectionVersion().getDate();
						}

						if( (StringUtils.isEmpty(lastEditorFilter) || StringUtils.contains(lastEditor, lastEditorFilter)) &&
							(StringUtils.isEmpty(editTimeFilter) || StringUtils.contains(editTime, editTimeFilter))

							){
								this.filteredBookList.add(book);

							}

					//this.filteredBookList.add(book);

				}
			}
		}

		if(completeBookList.size() > 0){
			this.filteringMessage = this.filteredBookList.size() + " book(s) listed after filtering";
			this.paginator.setCurrentPage(0);
			this.paginator.resetNumberOfPages(filteredBookList.size());
			this.updateCurrentBooks();
		}else{
			this.filteredBookList = null;
		}

	}


	private void updateCurrentBooks() {
		// update displayBookList using paginator

		this.paginator.initCount();
		int startRecord = this.paginator.getCurrentPage()
				* this.paginator.getItemsPerPage();

		if(this.paginator.getNumberOfPages() == 0){
			this.displayBookList = new ArrayList<DBBook>();
		}else if((this.paginator.getCurrentPage() + 1) == this.paginator.getNumberOfPages()){
			int mod = this.filteredBookList.size() % paginator.getItemsPerPage();
			if(mod == 0){
				this.displayBookList = filteredBookList.subList(startRecord, startRecord + this.paginator.getItemsPerPage());
			}else{
				this.displayBookList = filteredBookList.subList(startRecord, startRecord + mod);
			}

		}else{
			this.displayBookList = filteredBookList.subList(startRecord, startRecord + this.paginator.getItemsPerPage());
		}

	}


	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 getYearFilter() {
		return yearFilter;
	}


	public void setYearFilter(String yearFilter) {
		this.yearFilter = yearFilter;
	}

	public String getSourceFilter() {
		return yearFilter;
	}


	public void setSourceFilter(String sourceFilter) {
		this.sourceFilter = sourceFilter;
	}


	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();
			this.filteringMessage = null;
		}
	}

	public void forceLoadBooks(){
		logger.debug("force 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());

		}

		sortByBookIdUp();	//bookId ascend as default sorting
		// Note that every sortXYZ() function has filter() in it, so it will also force reload filteredList and displayList




	}

	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 {
			// update toc correction status to DB
			DBService.getInstance().updateTocCorrection(tocBookId, "1");

			// update toc correction status
			DBService.getInstance().getBook(tocBookId).setTocCorrection("1");

		}catch (Exception e) {
			addMsg("There is an internal error: " + e.getLocalizedMessage());
			e.printStackTrace();
		}

		//logger.debug("toc_correction:"+DBService.getInstance().getBook(tocBookId).getTocCorrection());

	}


	public void unSetTocCorrection() {
		String tocBookId = this.getTocBookId();
		logger.debug("tocFinishedBookId=" + tocBookId);
		try {
			DBService.getInstance().updateTocCorrection(tocBookId, "0");
			DBService.getInstance().getBook(tocBookId).setTocCorrection("0");

		}catch (Exception e) {
			addMsg("There is an internal error: " + e.getLocalizedMessage());
			e.printStackTrace();
		}

	}

	public void saveComment() {

		String bookComment = getParameter("bookComment");
		String currentBookId = getParameter("currentBookId");

		logger.debug("saveComment. currentBookId=" + currentBookId + ", bookComment: "+ bookComment);

		try {
			DBService.getInstance().updateComment(currentBookId, bookComment);
			//DBService.getInstance().getBook(currentBookId).setComments(bookComment);

		} 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 void sortByYearUp(){
		Collections.sort(this.completeBookList, new SortBooksByYear());
		filter();
	}

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

	public void sortBySourceUp(){
		Collections.sort(this.completeBookList, new SortBooksBySource());
		filter();
	}

	public void sortBySourceDown(){
		Collections.sort(this.completeBookList, new SortBooksBySource());
		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;
	}


	public void firstPage() {
		this.paginator.first();
		this.updateCurrentBooks();
	}

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

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

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

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

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


	public DataPaginator getPaginator() {
		return paginator;
	}

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



	public String getFilteringMessage() {
		return filteringMessage;
	}



	public void setFilteringMessage(String filteringMessage) {
		this.filteringMessage = filteringMessage;
	}

	public String getLastEditorFilter() {
		return lastEditorFilter;
	}

	public void setLastEditorFilter(String lastEditorFilter) {
		this.lastEditorFilter = lastEditorFilter;
	}
	public String getEditTimeFilter() {
		return editTimeFilter;
	}
	public void setEditTimeFilter(String editTimeFilter) {
		this.editTimeFilter = editTimeFilter;
	}

}