package dark.web.frame.controller;

import java.io.IOException;

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

import dark.web.frame.Message;
import dark.web.frame.command.AbstractCommand;
import dark.web.frame.command.UnknownCommand;
import dark.web.frame.form.AbstractForm;
import dark.web.frame.form.UnknownForm;
import dark.web.frame.page.AbstractPage;
import dark.web.frame.page.UnknownPage;

/**
 * <p>Title:            </p>
 * <p>Description:      </p>
 * <p>Copyright:        Copyright (c) 2004</p>
 * <p>Company:          DIS</p>
 * <p>Create Time:      2005-2-28 16:24:03</p>
 * @author             <a href="mailto:dark_he@hotmail.com">darkhe</a>
 * @version            1.0
 */
public class FrontController extends AbstractController
{	
	/**
	 * 	
	 * @param request
	 * @param response
	 * @throws ServletException
	 * @throws IOException
	 * @see dark.web.frame.controller.AbstractController#doRequest(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, dark.web.frame.Message)
	 */
	public void doRequest(
		HttpServletRequest request,
		HttpServletResponse response)
		throws ServletException, IOException
	{
		// 如果要求做表單驗證，則處理之
		if (isValidate(request))
		{

			String input = getInput(request);

			// 如果用戶沒有指定請求轉發路徑，則指定default value
			if (input.equals(""))
			{
				input = configuration.getString("default.input");

				log.warn(
					"dont't specify parameter $INPUT, use default.input:"
						+ input);
				request.setAttribute(
					"$WARM",
					"dont't specify parameter $INPUT, use default.input"
						+ input);
			}

			AbstractForm form = getForm(request);

			// 初始化表單驗證類
			form.init(getServletContext(), request, response, getMessage());

			// 設置當前表單驗證的用戶請求轉發路徑
			form.setInput(input);

			// 檢證表單驗證類的執行權限
			if (form.isAuthentic())
			{
				// 執行真實的驗證邏輯
				Message msg = form.validate();

				if (msg == null)
				{
					// 如果msg為null，則說明form類沒有返回Message實例
					input = configuration.getString("default.input");
					form.setInput(input);

					log.warn("valideate() don't return Message instance");
					request.setAttribute(
						"$WARM",
						"valideate() don't return Message instance");

					form.forward();
					return;
				}

				if (!msg.isEmpty())
				{
					// 如果msg不為空，則說明驗證出表單錯誤，									
					form.forward();
					return;
				}
			}
		}

		String target = getTarget(request);

		// 如果用戶沒有指定請求轉發路徑，則指定default value
		if (target.equals(""))
		{
			target = configuration.getString("default.target");

			log.warn(
				"don't specify paramter $TARGER, use default.target:" + target);
			request.setAttribute(
				"$WARM",
				"don't specify paramter $TARGER, use default.target:" + target);
		}

		AbstractCommand command = getCommand(request);

		// 初始化命令類
		command.init(
			getServletContext(),
			getServletConfig(),
			request,
			response);

		// 設置當前命令的用戶請求轉發路徑
		command.setTarget(target);

		// 檢證命令類的執行權限
		if (command.isAuthentic())
		{
			// 執行真實的商業邏輯
			command.process();
		}

		// 轉發請求到用戶指定路徑
		command.forward();
	}

	/**
	 * @param request
	 * @return
	 */
	protected boolean isValidate(HttpServletRequest request)
	{
		boolean isValidate = false;

		String validate = request.getParameter("$VALIDATE");
		if (validate == null || validate.length() == 0)
		{
			isValidate = false;
		}
		else if (
			validate.length() > 0 && validate.toLowerCase().equals("true"))
		{
			isValidate = true;
		}
		else
		{
			isValidate = false;
		}

		return isValidate;
	}

	/**
	 * @param request
	 * @return
	 */
	protected AbstractForm getForm(HttpServletRequest request)
		throws ServletException
	{
		try
		{
			return (AbstractForm) getFormClass(request).newInstance();
		}
		catch (Exception e)
		{
			throw new ServletException(e);
		}
	}

	/**
	 * @param request
	 */
	protected Class getFormClass(HttpServletRequest request)
	{
		Class result = null;

		String cp = configuration.getString("form.package");
		String formClassName = cp + "." + request.getParameter("$FORM");

		try
		{
			result = Class.forName(formClassName);
		}
		catch (ClassNotFoundException e)
		{
			log.error(
				"class:"
					+ formClassName
					+ " not found, return UnKnownForm.class");
			result = UnknownForm.class;
		}

		return result;
	}

	/**
	 * @param request
	 * @return
	 */
	protected String getInput(HttpServletRequest request)
	{
		String input = request.getParameter("$INPUT");
		if (input == null || input.length() == 0)
		{
			return "";
		}
		else
		{
			return input;
		}
	}

	/**
	 * 得到用戶指定的請求轉發路徑
	 * @param request
	 * @return 
	 */
	protected String getTarget(HttpServletRequest request)
	{
		String target = request.getParameter("$TARGET");
		if (target == null || target.length() == 0)
		{
			return "";
		}
		else
		{
			return target;
		}

	}

	/**
	 * 根據用戶請求中的Command參數所設置的處理程序全類名得到請求處理程序實例
	 * @param req
	 * @return
	 */
	protected AbstractCommand getCommand(HttpServletRequest request)
		throws ServletException
	{
		try
		{
			return (AbstractCommand) getCommandClass(request).newInstance();
		}
		catch (Exception e)
		{
			throw new ServletException(e);
		}
	}

	/**
	 * 通過類名串值到得類對象
	 * @param req
	 */
	protected Class getCommandClass(HttpServletRequest request)
	{
		Class result = null;

		String cp = configuration.getString("command.package");
		String commandClassName = cp + "." + request.getParameter("$COMMAND");

		try
		{
			result = Class.forName(commandClassName);
		}
		catch (ClassNotFoundException e)
		{
			log.error(
				"class:"
					+ commandClassName
					+ " not found, return UnknownCommand.class");
			result = UnknownCommand.class;
		}

		return result;
	}

	/**
	 * 得到當前請求的后綴
	 * @param request
	 * @return
	 */
	public static String getRequestPostfix(HttpServletRequest request)
	{
		String uri = request.getRequestURI();
		int index = uri.lastIndexOf('.');
		String postfix = uri.substring(index);
		return postfix;
	}

	/**
	 * 根據用戶請求中的URI得到頁面處理程序實例
	 * @param req
	 * @return
	 */
	protected AbstractPage getPage(HttpServletRequest request)
		throws ServletException
	{
		try
		{
			return (AbstractPage) getPageClass(request).newInstance();
		}
		catch (Exception e)
		{
			throw new ServletException(e);
		}
	}

	/**
	 * 通過類名串值到得類對象
	 * @param req
	 */
	protected Class getPageClass(HttpServletRequest request)
	{
		Class result = null;
	
		String cp = configuration.getString("page.package");
	
		String pageName = getPageName(request);
		String pageClassName = cp + "." + pageName;
	
		try
		{
			result = Class.forName(pageClassName);
		}
		catch (ClassNotFoundException e)
		{
			log.info(
				"class:"
					+ pageClassName
					+ " not found, return UnknownPage.class");
			result = UnknownPage.class;
		}
	
		return result;
	}

	/**
	 * @param request
	 * @return
	 */
	protected String getPageName(HttpServletRequest request)
	{
		String uri = request.getRequestURI();
		if (uri == null || uri.length() == 0)
		{
			return null;
		}

		if (uri.startsWith("/") && uri.length() > 1)
		{
			uri = uri.substring(1, uri.length());
		}

		// 得到在配置文件中指定的需要執行頁面處理程序的頁面的后綴名
		String postfix = configuration.getString("page.postfix");

		if (uri.endsWith(postfix) && uri.length() > postfix.length())
		{
			uri = uri.substring(0, uri.length() - postfix.length());
		}

		// 將/替換成.，以完成請求路徑到包路徑的轉換
		uri = uri.replaceAll("/", ".");

		return uri;
	}
}