package com.ganteater.ae.web;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.exception.ExceptionUtils;
import org.apache.logging.log4j.Level;

import com.ganteater.ae.AELogRecord;
import com.ganteater.ae.AEWorkspace;
import com.ganteater.ae.ChoiceTaskRunner;
import com.ganteater.ae.ILogger;
import com.ganteater.ae.Logger;
import com.ganteater.ae.RecipeRunner;

public class WebLogger implements ILogger {

        private List<WebLogRecord> logRecords = new ArrayList<WebLogRecord>();
        private RecipeRunner testRunner;
        private Object monitor = new Object();
        private WebInputItem input;
        private int maxRecordsInMemory = 50;
        private int startIndex = 0;
        private Logger logger;
        private String name;

        protected WebLogger(String name) {
                this.name = name;
                logger = new Logger(getName());
        }

        public Object error(Object message) {
                addLogRecord(null, message, Level.ERROR, null);
                message = logger.error(message);
                return message;
        }

        public Object error(Object message, Throwable t) {
                addLogRecord(null, message, Level.ERROR, t);
                message = logger.error(message, t);
                return message;
        }

        public Object debug(Object message) {
                addLogRecord(null, message, Level.DEBUG, null);
                message = logger.debug(message);
                return message;
        }

        public Object debug(Object message, Throwable t) {
                addLogRecord(null, message, Level.DEBUG, t);
                message = logger.debug(message, t);
                return message;
        }

        public Object info(Object message) {
                addLogRecord(null, message, Level.INFO, null);
                message = logger.info(message);
                return message;
        }

        public Object warn(Object message) {
                addLogRecord(null, message, Level.WARN, null);
                message = logger.warn(message);
                return message;
        }

        private void addLogRecord(String varName, Object message, Level level, Throwable t) {
                WebLogRecord element;

                if (message instanceof AELogRecord) {
                        AELogRecord rec = (AELogRecord) message;
                        element = new WebLogRecord(rec, level, varName);
                } else {
                        String text = ObjectUtils.toString(message);
                        element = new WebLogRecord(new AELogRecord(text, "txt", varName), level, varName);
                }

                if (t != null) {
                        element.setTrace(ExceptionUtils.getStackTrace(t));
                }

                if (logRecords.size() == maxRecordsInMemory) {
                        logRecords.remove(0);
                        startIndex++;
                }
                logRecords.add(element);
        }

        public List<WebLogRecord> getLog(int id) {
                List<WebLogRecord> result = new ArrayList<WebLogRecord>();
                int startIndex = id - this.startIndex;
                if (startIndex < 0) {
                        startIndex = 0;
                }
                for (int i = startIndex; i < logRecords.size(); i++) {
                        WebLogRecord record = logRecords.get(i);
                        record.setId(i + this.startIndex);
                        result.add(record);
                }
                return result;
        }

        public void setTestRunner(RecipeRunner testRunner) {
                this.testRunner = testRunner;
        }

        public RecipeRunner getTestRunner() {
                return testRunner;
        }

        public String inputValue(String name, String description, String defaultValue, String type) {
                input = new WebInputItem(name, description, defaultValue, type);
                synchronized (monitor) {
                        try {
                                monitor.wait();
                        } catch (InterruptedException e) {
                                Thread.currentThread().interrupt();
                        }
                }
                String value = input.getValue();
                input = null;
                return value;
        }

        public void applyInput(String[] value) {
                if (input instanceof WebChoiceItem) {
                        ((WebChoiceItem) input).select(value);

                } else if (input instanceof WebInputItem && ArrayUtils.isNotEmpty(value)) {
                        input.setValue(value[0]);
                        AEWorkspace.getInstance().setDefaultUserConfiguration(".inputValue." + name, value[0]);

                }
                synchronized (monitor) {
                        monitor.notify();
                }
        }

        public WebInputItem getInput() {
                return input;
        }

        public void inputChoice(ChoiceTaskRunner tasksChoice) {
                input = new WebChoiceItem(tasksChoice);
                synchronized (monitor) {
                        try {
                                monitor.wait();
                        } catch (InterruptedException e) {
                                Thread.currentThread().interrupt();
                        }
                }
                tasksChoice.start();
                input = null;
        }

        public String inputSelectChoice(String name, String description, String[] value, String defaultValue) {
                input = new WebSelectItem(name, description, value, defaultValue);
                synchronized (monitor) {
                        try {
                                monitor.wait();
                        } catch (InterruptedException e) {
                                //
                        }
                }
                String result = input.getValue();
                input = null;
                return result;
        }

        public String inputChoiceValue(String name, String desc, Object[] aPossibleValues, String value) {
                input = new WebSelectItem(name, desc, aPossibleValues, value);
                synchronized (monitor) {
                        try {
                                monitor.wait();
                        } catch (InterruptedException e) {
                                //
                        }
                }
                value = input.getValue();
                if (WebSelectItem.CANCEL_X == value) {
                        value = null;
                }
                input = null;
                return value;
        }

        public String inputFile(String name, File aDefaultFile, ILogger log) {
                input = new FileUploadItem(name, aDefaultFile);
                synchronized (monitor) {
                        try {
                                monitor.wait();
                        } catch (InterruptedException e) {
                                //
                        }
                }
                String value = input.getValue();
                if (WebSelectItem.CANCEL_X == value) {
                        value = null;
                }
                input = null;
                return value;
        }

        public WebLogRecord getRecord(int id) {
                int index = id - startIndex;
                if (index < 0) {
                        return new WebLogRecord(
                                        new AELogRecord("The record is no longer in a memory. Please see server log file .", "txt", null),
                                        Level.ERROR, null);
                }
                return logRecords.get(index);
        }

        public void reset() {
                synchronized (monitor) {
                        monitor.notify();
                }
        }

        public int getStartIndex() {
                return startIndex;
        }

        synchronized public void moveToArchive() {
                this.startIndex = logRecords.size();
                logRecords.clear();
        }

        @Override
        public String getName() {
                return name;
        }

        @Override
        public boolean isFilterEnabled() {
                // TODO Auto-generated method stub
                return false;
        }

        @Override
        public String filter(Object message) {
                // TODO Auto-generated method stub
                return null;
        }

}