import java.util.*;
import javax.servlet.http.*;
import org.apache.log4j.spi.*;
import javax.servlet.*;
import java.io.*;
import org.apache.log4j.*;
import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.stream.*;
import org.apache.xerces.parsers.*;
import org.w3c.dom.*;
import java.lang.Long;

//Most of the html stuff in here is quite roughly done. normally id be sane and use a library but I dont know what you wanted so i figured id do it this way.
//in most projects like this i would have created a seperate servlet to act as a rest service, but in the case of this one ive made it so that the get request
//passes a "service" parameter to determine what to send back.
public class Demo extends HttpServlet{

    private LogDB logDB;

    public Demo()
    {

    }

    public void doGet(HttpServletRequest request, HttpServletResponse response)
    {
    PrintWriter writer = null;
    try
    {
        writer = response.getWriter();
    }
    catch(Exception e)
    {
        System.out.println(e.getMessage());
    }
    if(request.getParameter("service") == null)
    {
        writer.write(this.getPage());
        return;
    }
    if(request.getParameter("service").equals("update"))
    {
        String logger = request.getParameter("logger");
        Level level = Level.toLevel(request.getParameter("level"));
        response.setContentType("text/xml");
        response.setHeader("Cache-Control", "no-cache");
        response.setHeader("Pragma", "no-cache");

        try{
        Document document = this.getXML(level, logger);
        Source source = new DOMSource(document);
        Result result = new StreamResult(response.getWriter());
        Transformer xformer = TransformerFactory.newInstance().newTransformer();
        xformer.transform(source, result);
        }
        catch(Exception e)
        {
        System.out.println(e.getMessage());
        }

    }
    else
    if(request.getParameter("service").equals("delete"))
    {
        this.logDB.reset();
    }
    else
    {
        writer.write(this.getPage());
    }
    }

    /**
       All of the init stuff goes in here. the connection details are read from the web.xml config file.
     **/
    public void init()
    {
    this.logDB = new LogDB();
    ServletConfig config = getServletConfig();
    String user = config.getInitParameter("user");
    String password = config.getInitParameter("password");
    String url = config.getInitParameter("url");
    String table = config.getInitParameter("table");
    String database = config.getInitParameter("database");
    this.logDB.setDetails(table, user, password, url, database);
    this.logDB.connect();
    }

    /**

     **/
    public String getSearchForm()
    {
    StringBuffer output = new StringBuffer();
    output.append("<form id = 'SearchForm'>");
    output.append("<table>");
    output.append(getTextSearchRow());
    output.append(getLevelRow());
    output.append(getNumberOfResultsRow());
    output.append(getLoggerRow());
    output.append(getUpdateButton());
    output.append("</table>");
    output.append("</form>");
    return output.toString();
    }

    public String getUpdateButton()
    {
    StringBuffer output = new StringBuffer();
    output.append("<tr>");
    output.append("<td>");
    output.append("<input type = 'button' onClick = 'updateValues()' value='update'/>");
    output.append("</td>");
    output.append("</tr>");
    return output.toString();
    }

    public String getRow(String data1, String data2)
    {
    StringBuffer output = new StringBuffer();
    output.append("<tr>");
    output.append("<td>");
    output.append(data1);
    output.append("</td>");
    output.append("<td>");
    output.append(data2);
    output.append("</td>");
    output.append("</tr>");
    return output.toString();
    }

    public String getNumberOfResultsRow()
    {
    return getRow("Maximum Results", "<input type = 'text' name = 'numberResults' id = 'numberResults'");
    }

    public String getTextSearchRow()
    {
    return getRow("Search", "<input type = 'text' name = 'search' id = 'search'");
    }

    public String getLevelRow()
    {
    return getRow("Level", getLevelOptions());
    }

    public String getLoggerRow()
    {
    return getRow("Logger", "<input type = 'text' name = 'logger' id = 'loggerEntry'");
    }

    public String getLevelOptions()
    {
    StringBuffer options = new StringBuffer();
    options.append("<select id = 'levelSelect' name = 'levelSelect'>");
    options.append("<option>DEBUG</option>");
    options.append("<option>WARN</option>");
    options.append("<option>INFO</option>");
    options.append("<option>ERROR</option>");
    options.append("<option>ALL</option>");
    options.append("</select>");
    return options.toString();
    }

    public String getResultsXml()
    {
    String output = new String();
    return output;
    }

    public String getPage()
    {
    StringBuffer page = new StringBuffer();
    page.append("<html>");
    page.append("<head>");
    page.append("<script type = 'text/javascript' src = 'Demo.js'></script>");

    page.append("</head>");
    page.append("<body onload='init()'>");
    page.append("<div id = 'Events'>");
    page.append("</div>");
    page.append(this.getSearchForm());
    page.append("</body>");
    page.append("<html>");
    return page.toString();
    }



    public Document getXML(Level level, String logger) throws ParserConfigurationException
    {
    Iterator<LoggingEvent> events = this.logDB.getLogEvents(level, logger);
    DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = dbfac.newDocumentBuilder();
        Document document = docBuilder.newDocument();

    Element root = document.createElement("Events");
    while(events.hasNext())
    {
        System.out.println("looping");
        LoggingEvent e = events.next();
        root.appendChild(this.getLoggingEventXml(e, document));
    }
    document.appendChild(root);
    return document;
    }

    public Element getLoggingEventXml(LoggingEvent event, Document document)
    {
    Element root = document.createElement("Event");

    Element logger = document.createElement("Logger");
    Text loggerText = document.createTextNode(event.getLoggerName());
    logger.appendChild(loggerText);
    Element message = document.createElement("Message");
    Text messageText = document.createTextNode(event.getMessage().toString());
    message.appendChild(messageText);
    Element level = document.createElement("Level");
    Text levelText = document.createTextNode(event.getLevel().toString());
    level.appendChild(levelText);
    Element time = document.createElement("Time");
    Text timeText = document.createTextNode(new Long(event.getTimeStamp()).toString());
    time.appendChild(timeText);


    root.appendChild(time);
    root.appendChild(logger);
    root.appendChild(message);
    root.appendChild(level);

    return root;
    }
}import javax.servlet.*;
import java.io.*;
import javax.servlet.http.*;

public class Index extends HttpServlet
{
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
    {
    response.setHeader("content-type", "text/html");
    PrintWriter out = response.getWriter();
    out.write("<html>");
    out.write("");
    out.write("</html>");
    }
}import java.sql.*;
import java.util.*;
import java.io.*;
import org.apache.log4j.spi.*;
import org.apache.log4j.*;

public class LogDB{


    private Connection connection;
    private String url;
    private String user;
    private String password;
    private String database;
    private String table;

    public LogDB()
    {

    }

    public void reset()
    {
    try
    {
        String statementString = "delete from " + this.table;
        Statement statement = this.connection.createStatement();
        statement.execute(statementString);
    }
    catch(Exception e)
    {
        System.out.println(e.getMessage());
    }
    }

    public void setDetails(String table, String user, String password, String url, String database)
    {
    this.table = table;
    this.password = password;
    this.user = user;
    this.url = url;
    this.database = database;
    }

    public void connect()
    {
    try
    {
        Class.forName("com.mysql.jdbc.Driver").newInstance();
        String connectString = "jdbc:mysql://" + this.url + "/" + this.database + "?user=" + this.user + "&password=" +this.password;
        this.connection = DriverManager.getConnection(connectString);
    }
    catch(Exception e)
    {

    }

    }

    public Iterator<LoggingEvent> getLogEvents(Level level, String loggerName)
    {
    ArrayList<LoggingEvent> events = new ArrayList<LoggingEvent>();
    try
    {
        String statementString = new String("select * from " + this.table + " where logger = " + "'"+loggerName+"' and level = " + "'" + level.toString() + "' order by timeStamp desc");
        System.out.println(statementString);
        Statement statement = connection.createStatement();
        ResultSet rs = statement.executeQuery(statementString);
        InputStream is = null;
        ObjectInputStream ois = null;
        while(rs.next())
        {
        is = rs.getBlob("event").getBinaryStream();
        ois = new ObjectInputStream(is);
        LoggingEvent e = (LoggingEvent)ois.readObject();
        events.add(e);
        System.out.println(e.getMessage());
        }
    }
    catch(Exception e)
    {
        System.out.println("blah" + e.getMessage());
    }
    return events.iterator();
    }

}import org.apache.log4j.spi.*;
import org.apache.log4j.*;
import java.lang.*;
import java.util.*;
/**
I should justify this class. Hibernate requires quite a few things that LoggingEvent simply doesnt offer, such as a no arguments constructor.
As a solution to this problem and in order to save my sanity, I have implemented this class as a wrapper. It contains a LoggingEvent and the idea is that
instead of storing a LoggingEvent directly I will store this class. It provides better setters and getters and provides the all important no arguments constructor.
The downside is that it doesnt know what kind of LoggingEvent it should store. As a result it implements a default one, this is fine as long as its correctly setup
The class itself doesn't store much information, mostly just passes back and forth between the LoggingEvent.
 **/

class LoggingEventWrapper{

    private LoggingEvent event;
    private String loggerName;
    private String message;
    private int level;
    private long date;

    public LoggingEventWrapper()
    {
    Logger logger = Logger.getRootLogger();
    Priority priority = Level.toLevel(0);
    Object message = new Object();
    Throwable throwable = new Throwable();
    event.timeStamp = date;
    LoggingEvent event = new LoggingEvent("", logger, priority, message, throwable);
    }

    public Date getDate()
    {
    //due to the fact that the LoggingEvent stores its date as a long from 1970 ill make a new and improved date function
    //this way it can be stored directly into the database as a date
    return new Date(this.event.getTimeStamp());
    }

    public void setDate(Date date)
    {
    this.date = date.getTime();
    }

    public LoggingEvent getEvent()
    {
    Logger logger = Logger.getLogger(this.loggerName);
    Priority priority = Level.toLevel(this.level);
    Throwable throwable = new Throwable();
    LoggingEvent event = new LoggingEvent("", logger, priority, message, throwable);
    return event;
    }

    public void setEvent(LoggingEvent event)
    {
    this.event = event;
    }

    public String getMessage()
    {
    return this.event.getRenderedMessage();
    }

    public void setMessage(String message)
    {
    this.message = message;
    }

    public String getLoggerName()
    {
    return this.event.getLoggerName();
    }

    public void setLoggerName(String name)
    {
    this.loggerName = name;
    }

}import javax.servlet.http.*;
import org.apache.log4j.*;

public class Log extends HttpServlet
{
    public void init()
    {

    }

    public void doGet(HttpServletRequest request, HttpServletResponse response)
    {
    try
    {
        String level = request.getParameter("level");
        String logger = request.getParameter("logger");
        String message = request.getParameter("message");
        response.getWriter().write("boo");
        Logger theLogger = Logger.getLogger(logger);
        theLogger.log(Level.toLevel(level), message);
    }
    catch(Exception e)
    {
    }
    }
}import org.apache.log4j.*;
import org.apache.log4j.spi.*;
import java.util.*;
import java.sql.*;

public class MyAppender implements Appender{

    public String user;
    private String url;
    private String password;
    private String name;
    private String database;
    private String table;

    private ArrayList<LoggingEvent> loggingEvents;
    private ArrayList<Filter> filters;
    private Layout layout;
    private ErrorHandler errorHandler;

    public MyAppender()
    {
    this.loggingEvents = new ArrayList<LoggingEvent>();
    this.filters = new ArrayList<Filter>();
    this.layout = null;
    this.errorHandler = null;
    //fix this lot later
    this.user = "root";
    this.password = "f5g7eaef";
    this.url = "localhost";
    this.database="assignment";
    this.table = "test";
    }

    public void activateOptions()
    {
    System.out.println("acti");
    }

    public void close()
    {
    }

    public void append(LoggingEvent e)
    {
    this.loggingEvents.add(e);
    }

    public boolean requiresLayout()
    {
    return false;
    }

    public String getName()
    {
    return this.name;
    }

    public void setName(String name)
    {
    this.name = name;
    }

    public void addFilter(Filter filter)
    {
    this.filters.add(filter);
    }

    public Layout getLayout()
    {
    return this.layout;
    }

    public void setLayout(Layout layout)
    {
    this.layout = layout;
    }

    public Filter getFilter()
    {
    return this.filters.get(0);
    }


    public void doAppend(LoggingEvent event)
    {
    try{
        Class.forName("com.mysql.jdbc.Driver").newInstance();
        String connectString = "jdbc:mysql://" + this.url + "/" + this.database + "?user=" + this.user + "&password=" +this.password;
        Connection connection = DriverManager.getConnection(connectString, this.user, this.password);
        PreparedStatement statement = getPreparedStatement(event, connection);
        statement.execute();
    }
    catch(Exception e)
    {
        System.out.println("nooooooooo" + e.getMessage());
    }
    }

    public PreparedStatement getPreparedStatement(LoggingEvent event, Connection connection)
    {
    try{
    String prepared =getPreparedString();
    PreparedStatement statement = connection.prepareStatement(prepared);
    statement.setObject(1, event);
    statement.setString(2, event.getRenderedMessage());
    statement.setString(3, event.getLoggerName());
    statement.setString(4, event.getLevel().toString());
    statement.setLong(5, event.getTimeStamp());
    return statement;
    }
    catch(Exception e)
    {
        System.out.println(e.getMessage());
        return null;
    }
    }

    public String getPreparedString()
    {
    return new String("insert into " + this.table + " (event, message, logger, level, timeStamp) values(?,?,?, ?, ?)");
    }

    public void setErrorHandler(ErrorHandler handler)
    {
    this.errorHandler = handler;
    }

    public ErrorHandler getErrorHandler()
    {
    return this.errorHandler;
    }

    public void clearFilters()
    {
    this.filters.clear();
    }

    public String getUser()
    {
    return this.user;
    }

    public void setUser(String user)
    {
    this.user = user;
    }

    public String getUrl()
    {
    return this.url;
    }

    public String getPassword()
    {
    return this.password;
    }

    public void setUrl(String url)
    {
    this.url = url;
    }
    public void setPassword(String password)
    {
    this.password = password;
    }
}class MyLoggingEvent extends LoggingEventimport org.apache.log4j.spi.*;

//I am cheating, hibernate requires a great many things that LoggingEvent doesnt have such as a no arguments constructor
//and hibernate is driving me insane.
//by writing this class I still have a LoggingEvent, just a better one, and i keep my sanity.
//thank you.
class MyLoggingEvent extends LoggingEvent
{
    MyLoggingEvent()
    {
    super(null, null, null, null, null);
    //this is a no argument constructor.
    }
}import java.sql.*;
import java.util.*;
import java.io.*;
import org.apache.log4j.spi.*;
import org.apache.log4j.*;
import org.apache.log4j.Level;
public class test{

    public static void main(String[] args)
    {
    LogDB log = new LogDB();
    Iterator<LoggingEvent> events = log.getLogEvents(Level.toLevel("INFO"), "root");
    while(events.hasNext())
        {
        LoggingEvent e = events.next();
        System.out.println(e.getMessage());
        }
    }
}import javax.servlet.*;
import java.io.*;
import javax.servlet.http.*;
import soup.*;
import org.apache.log4j.*;


public class Word extends  HttpServlet
{

    public static final long serialVersionUID = 1;
    private static final Logger logger = Logger.getRootLogger();

    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
    {
    logger.debug("foo:this is info, bar:debug");
    logger.info("bar:this is debug, foo:info");

    PrintWriter writer = response.getWriter();
    writer.print("<html>");
    writer.print(this.getHead());

    if(request.getParameter("word1") != null)
        {
        soup.Board board = new soup.Board(Integer.parseInt(request.getParameter("width")),Integer.parseInt(request.getParameter("height")));
        for(int i = 1; true; i++)
            {
            if(request.getParameter("word" + Integer.toString(i)) != null)
                board.addWord(request.getParameter("word" + Integer.toString(i)));
            else
                break;
            }
        board.fillBoard();

        //output the html
        writer.write(this.getSoup(board));
        }



    writer.write(this.getForm());
    writer.print("</html>");
    }


    private String getForm()
    {
    String form = "";
    form += "<form action = 'Index.html' method = 'get' onsubmit='return checkSubmission()'>";

    form += "<div id = 'words'>";
    form += "<div id = entryDiv1><input type = text name = 'word1' id = 'word1'></div>";
    form += "</div>";
    form += "<input type = button onclick = 'createWord()' value = 'add word'>";
    form += "<br>";
    form += "<div class = sizeLabel>";
    form += "height";
    form += "</div>";
    form += "<div class = sizeEntry id = heightDiv>";
    form += "<input type = text name = height id = heightEntry>";
    form += "</div>";
    form += "<div class = sizeLabel>";
    form += "width";
    form += "</div>";
    form += "<div class = sizeEntry id = 'widthDiv'>";
    form += "<input type = text name = width id = widthEntry>";
    form += "</div>";
    form += "<input type = submit value = 'Get Word Soup!'>";
    form += "</form>";
    return form;
    }

    private String getSoup(Board board)
    {
    String soup = "";
    soup += "<div id = 'Soup'";
    soup += "<table border = solid 1px>";
    for(int i = 0; i < board.getHeight(); i++)
        {
        soup += "<tr>";
        for(int j = 0; j < board.getWidth(); j++)
            {
            soup += "<td>";
            soup += board.getXY(j,i);
            soup += "</td>";
            }
        soup += "</tr>";
        }
    soup += "</table>";
    soup += "</div>";
    return soup;
    }

    private String getHead()
    {
    String head = "";
    head += "<head>";
    head += "<script type = text/javascript src = 'words.js'>";
    head += "</script>";
    head += "</head>";
    return head;
    }
}