package geekblog.filters;


import java.io.*;
import java.lang.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.prefs.*;
import javax.servlet.*;
import javax.servlet.http.*;
import geekblog.*;
import org.apache.commons.fileupload.*;


/**
 * Filter to handle all "action" (a.k.a. Controller) processing in front of
 * index.jsp.
 */
public class ActionFilter
  implements Filter
{
  private FilterConfig config;
  private ServletContext application;
  private DataManager dm;
  private Preferences blogPrefs;

  
  public void init(FilterConfig cfg)
  {
    config = cfg;
    application = config.getServletContext();
  }
  public void destroy()
  {
  }


  public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
    throws ServletException, IOException
  {
    ServletContext application = config.getServletContext();
    HttpServletRequest request = (HttpServletRequest)req;
    HttpServletResponse response = (HttpServletResponse)resp;

    if (dm == null)
      dm = (DataManager)application.getAttribute(DataManager.KEY);

    if (blogPrefs == null)
    {
      String ctx = request.getContextPath();
      blogPrefs = Preferences.systemRoot().node("net/sourceforge/geekblog" + ctx);
    }
    
    if (FileUpload.isMultipartContent(request))
    {
      application.log("Is multipart-formdata");
      request = new MultipartHttpServletRequest(request, application.getRealPath("/WEB-INF"));
    }
    else
    {
      application.log("Nope, no multipart-formdata here, no siree....");
    }

    // Do any processing that needs to be done
    //
    String action = request.getParameter("action");
    if (action != null)
    {
      if (action.equals("login"))
        process_login(request, response);
      else if (action.equals("save"))
        process_save(request, response);
      else if (action.equals("addlink"))
        process_addlink(request, response);
      else if (action.equals("addblogroll"))
        process_addblogroll(request, response);
      else if (action.equals("search"))
        process_search(request, response);
      else if (action.equals("savepage"))
        process_savepage(request, response);
    }

    Collection entries = findBlogEntries(request, response);

    // TODO: Verify this logic--how *exactly* are we supposed to handle
    // this? I'm not entirely sure what the algorithm's supposed to look like. --TKN
    //
    if (request.getDateHeader("If-Modified-Since") != -1)
    {
      BlogEntry mostRecentEntry = (BlogEntry)entries.iterator().next();
      if (mostRecentEntry != null)
      {
        Date ts = mostRecentEntry.getTimestamp();
        Date ims = new Date(request.getDateHeader("If-Modified-Since"));

        if (ts.getTime() > ims.getTime())
        {
          response.setDateHeader("Last-Modified", ts.getTime());
        }
        else
        {
          // ???
        }
      }
    }

    chain.doFilter(request, response);
  }

  private void process_login(HttpServletRequest request, HttpServletResponse response)
  {
    String userid = request.getParameter("userid");
    String password = request.getParameter("password");

    if (userid.equals(blogPrefs.get("userid", null)) && 
        password.equals(blogPrefs.get("password", null)))
    {
      HttpSession session = request.getSession(true);
      session.setAttribute("userid", userid);
    }
  }

  private void process_save(HttpServletRequest req, HttpServletResponse response)
  {
    MultipartHttpServletRequest request = (MultipartHttpServletRequest)req;

    if (request.getSession(false) == null)
    {
      // Do nothing
    }
    else
    {
      // There were no files; proceed normally
      //
      String id = request.getParameter("entryID");
      String tt = request.getParameter("title");
      String tx = request.getParameter("text");
      String ar = request.getParameter("article");

      // Save off the file someplace
      //
      int suffix = 0;
      while (true)
      {
        FileItem fileItem = request.getFileParameter("file_" + suffix);
        String fileDest = request.getParameter("filedest_" + suffix);

        if (fileItem == null || fileItem.getName().equals(""))
        {
          break;
        }
        else
        {
          // Save off file to destination
          //
          File sourceFile = fileItem.getStoreLocation();
          File destFile = new File(application.getRealPath("/"), fileDest);
          File destDir = new File(destFile.getParent());
          if (!destDir.exists())
          {
            destDir.mkdirs();
          }

          try
          {
            FileInputStream fis = new FileInputStream(sourceFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            BufferedInputStream bis = new BufferedInputStream(fis);
            byte[] buffer = new byte[1024];
            int ct = 0;
            while ((ct = bis.read(buffer, 0, buffer.length)) != -1)
              fos.write(buffer, 0, ct);
            bis.close();
            fis.close();
            fos.close();
          }
          catch (IOException IOEx)
          {
            throw new RuntimeException("Error in writing " + sourceFile + " to " + destFile, IOEx);
          }

          suffix++;
        }
      }

      BlogEntry entry;
      if (id.equals("0"))
        entry = new BlogEntry(tt, tx);
      else
      {
        entry = dm.getEntry(Long.parseLong(id));
        entry.setTitle(tt);
        entry.setText(tx);
      }

      dm.postEntry(entry);

      if (ar != null)
      {
        dm.markAsArticle(entry);
      }
    }
  }

  private void process_addlink(HttpServletRequest request, HttpServletResponse response)
    throws IOException
  {
    if (request.getSession(false) == null)
    {
      // Do nothing
    }
    else
    {
      String linkName = request.getParameter("linktitle");
      String linkURL = request.getParameter("linkurl");
  
      FileWriter fw = new FileWriter(application.getRealPath("/WEB-INF/links.jsp"), true);
      PrintWriter pw = new PrintWriter(fw);
  
      pw.println("<a href=\"" + linkURL + "\">" + linkName + "</a><br />");
  
      pw.close();
      fw.close();
    }
  }

  private void process_addblogroll(HttpServletRequest request, HttpServletResponse response)
    throws IOException
  {
    if (request.getSession(false) == null)
    {
      // Do nothing
    }
    else
    {
      String linkName = request.getParameter("blogrolltitle");
      String linkURL = request.getParameter("blogrollurl");
      String linkRSSURL = request.getParameter("blogrollrssurl");
  
      FileWriter fw = new FileWriter(application.getRealPath("/WEB-INF/blogroll.jsp"), true);
      PrintWriter pw = new PrintWriter(fw);
  
      pw.println("<a href=\"" + linkURL + "\">" + linkName + "</a> (<a href=\"" + linkRSSURL + "\">RSS</a>)<br />");
  
      pw.close();
      fw.close();
    }
  }

  private void process_search(HttpServletRequest request, HttpServletResponse response)
  {
    String searchText = request.getParameter("search");

    request.setAttribute("geekblog.entries", dm.findEntries(searchText));
  }

  private void process_savepage(HttpServletRequest request, HttpServletResponse response)
    throws IOException
  {
    String fileContents = request.getParameter("pagecontent");
    String filename = request.getParameter("filename");

    FileWriter fw = new FileWriter(application.getRealPath(filename));
    fw.write(fileContents, 0, fileContents.length());

    fw.close();
  }

  private Collection findBlogEntries(HttpServletRequest request, HttpServletResponse response)
  {
    GregorianCalendar workingDate = new GregorianCalendar();
    Collection entries = null;

    String action = request.getParameter("action");
    if (action != null && action.equals("search"))
    {
      // Entries were already found, workingDate is already correct, just no-op
      // 
    }
    else
    {
      // We need to look up the entries for the current date, or the date
      // passed in via query param
      //
      String date = request.getParameter("date");
      String month = request.getParameter("month");
      String all = request.getParameter("all");
      if (date != null)
      {
        try
        {
          workingDate.setTime(new SimpleDateFormat("yyyyMMdd").parse(date));
          entries = dm.getEntriesForDate(workingDate.getTime());
        }
        catch (ParseException parseEx)
        {
          // Fall through to final check, below
        }
      }
      else if (month != null)
      {
        try
        {
          workingDate.setTime(new SimpleDateFormat("yyyyMM").parse(month));
          entries = dm.getEntriesForMonth(workingDate.getTime());
        }
        catch (ParseException parseEx)
        {
          // Fall through to final check, below
        }
      }
      else if (all != null)
        entries = dm.getAllEntries();

      // TODO: change this to read number of entries from blogPrefs "weblog.recententries"
      //
      int recentEntries = blogPrefs.getInt("weblog.recententries", 15);
      if (entries == null)
        entries = dm.getLastNEntries(recentEntries);
    }

    request.setAttribute("geekblog.entries", entries);
    request.setAttribute("workingDate", workingDate);

    return entries;
  }
}


/**
 * Why is there no HttpServletRequestWrapper? I want to silently replace the
 * HttpServletRequest with a Wrapper that provides the exact same interface, yet
 * wraps around multipart-formdata. Doing this lets me support both "normal" and
 * multipart-formdata without having to write anything different in the JSPs or
 * servlets.
 */
class MultipartHttpServletRequest extends ServletRequestWrapper
  implements HttpServletRequest
{
  private Map fileMap = new HashMap();
  private Map parameterMap = new HashMap();
  private HttpServletRequest request;


  /**
   * Wrap (Decorate, in GOF terms) a HttpServletRequest, adding functionality
   * to consume a multipart-formdata request and serve it back via the
   * standard HttpServletRequest methods. We add a few methods to be used in
   * the event that (request instanceof MultipartHttpServletRequest) == true
   * from within the JSP/servlet.
   */
  public MultipartHttpServletRequest(HttpServletRequest r, String repositoryPath)
  {
    super(r);
    
    request = r;

    Map originalParamMap = r.getParameterMap();
    for (Iterator iter = originalParamMap.keySet().iterator(); iter.hasNext(); )
    {
      Object key = iter.next();
      parameterMap.put(key, originalParamMap.get(key));
    }

    FileUpload fu = new FileUpload();

    fu.setSizeMax(5000000);
    fu.setSizeThreshold(4096);
    fu.setRepositoryPath(repositoryPath);

    try
    {
      List fileItems = fu.parseRequest(request);
      for (Iterator iter = fileItems.iterator(); iter.hasNext(); )
      {
        FileItem current = (FileItem)iter.next();

        if (current.isFormField())
        {
          parameterMap.put(current.getFieldName(), current.getString());
        }
        else
        {
          parameterMap.put(current.getFieldName(), current);
          fileMap.put(current.getName(), current);
        }
      }
    }
    catch (FileUploadException fuEx)
    {
      throw new RuntimeException("Error in parsing multipart-formdata: " + fuEx);
    }
  }


  /**
   *
   */
  public Iterator getFiles()
  {
    return fileMap.values().iterator();
  }
  /**
   *
   */
  public Iterator getFileNames()
  {
    return fileMap.keySet().iterator();
  }
  /**
   *
   */
  public byte[] getFile(String name)
  {
    Object o = fileMap.get(name);
    FileItem fi = (FileItem)o;
    return fi.get();
  }


  // ================================================================
  //                                         ServletRequest methods
  // ================================================================
  /**
   *
   */
  public String getParameter(String paramName)
  {
    String retval = null;
    if ((retval = request.getParameter(paramName)) == null)
      retval = (String)parameterMap.get(paramName);
    
    return retval;
  }
  /**
   *
   */
  public FileItem getFileParameter(String paramName)
  {
    return (FileItem)parameterMap.get(paramName);
  }
  /**
   *
   */
  public Enumeration getParameterNames()
  {
    final Enumeration enum = request.getParameterNames();
    final Iterator iter = parameterMap.keySet().iterator();
    return new Enumeration()
      {
        public boolean hasMoreElements() 
        {
          return (enum.hasMoreElements() || iter.hasNext());
        }
        public Object nextElement() 
        {
          if (enum.hasMoreElements())
          {
            return enum.nextElement();
          }
          else if (iter.hasNext())
          {
            return iter.next();
          }
          return null;
        }
      };
  }
  /**
   *
   */
  public String[] getParameterValues(String paramName)
  {
    throw new UnsupportedOperationException("Sorry; can't do this");
  }
  /**
   *
   */
  public Map getParameterMap()
  {
    throw new UnsupportedOperationException("Sorry; can't do this");
  }


  // ================================================================
  //                                     HttpServletRequest methods
  // ================================================================
  public String getAuthType()
  {
    return request.getAuthType();
  }
  public Cookie getCookies()[]
  {
    return request.getCookies();
  }
  public long getDateHeader(String headerName)
  {
    return request.getDateHeader(headerName);
  }
  public String getHeader(String headerName)
  {
    return request.getHeader(headerName);
  }
  public Enumeration getHeaders(String headerNames)
  {
    return request.getHeaders(headerNames);
  }
  public Enumeration getHeaderNames()
  {
    return request.getHeaderNames();
  }
  public int getIntHeader(String headerName)
  {
    return request.getIntHeader(headerName);
  }
  public String getMethod()
  {
    return request.getMethod();
  }
  public String getPathInfo()
  {
    return request.getPathInfo();
  }
  public String getPathTranslated()
  {
    return request.getPathTranslated();
  }
  public String getContextPath()
  {
    return request.getContextPath();
  }
  public String getQueryString()
  {
    return request.getQueryString();
  }
  public String getRemoteUser()
  {
    return request.getRemoteUser();
  }
  public boolean isUserInRole(String role)
  {
    return request.isUserInRole(role);
  }
  public Principal getUserPrincipal()
  {
    return request.getUserPrincipal();
  }
  public String getRequestedSessionId()
  {
    return request.getRequestedSessionId();
  }
  public String getRequestURI()
  {
    return request.getRequestURI();
  }
  public StringBuffer getRequestURL()
  {
    return request.getRequestURL();
  }
  public String getServletPath()
  {
    return request.getServletPath();
  }
  public HttpSession getSession(boolean force)
  {
    return request.getSession(force);
  }
  public HttpSession getSession()
  {
    return request.getSession();
  }
  public boolean isRequestedSessionIdValid()
  {
    return request.isRequestedSessionIdValid();
  }
  public boolean isRequestedSessionIdFromCookie()
  {
    return request.isRequestedSessionIdFromCookie();
  }
  public boolean isRequestedSessionIdFromURL()
  {
    return request.isRequestedSessionIdFromURL();
  }
  public boolean isRequestedSessionIdFromUrl()
  {
    return request.isRequestedSessionIdFromUrl();
  }
}