package ru.prolib.aquila.core.BusinessEntities;

import java.util.List;

import org.joda.time.DateTime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import ru.prolib.aquila.core.*;
import ru.prolib.aquila.core.BusinessEntities.CommonModel.*;
import ru.prolib.aquila.core.BusinessEntities.utils.*;
import ru.prolib.aquila.core.utils.*;

/**
 * Basic terminal.
 * <p>
 * Basic terminal functionality implementation.
  */
public class BasicTerminal implements EditableTerminal {
    private static Logger logger;
    private volatile TerminalState state = TerminalState.STOPPED;
    private final EventSystem es;
    private final Securities securities;
    private final Portfolios portfolios;
    private final Orders orders;
    private final StarterQueue starter;
    private final Scheduler scheduler;
    private final TerminalEventDispatcher dispatcher;
    private final TerminalController controller;
    private final OrderProcessor orderProcessor;

    static {
        logger = LoggerFactory.getLogger(BasicTerminal.class);
    }

    /**
     * Constructor.
     * <p>
     * @param params - basic terminal constructor parameters
     */
    public BasicTerminal(BasicTerminalParams params) {
        super();
        this.controller = params.getController();
        this.dispatcher = params.getEventDispatcher();
        this.securities = params.getSecurityStorage();
        this.portfolios = params.getPortfolioStorage();
        this.orders = params.getOrderStorage();
        this.starter = params.getStarter();
        this.scheduler = params.getScheduler();
        this.es = params.getEventSystem();
        this.orderProcessor = params.getOrderProcessor();
    }

    @Override
    public OrderProcessor getOrderProcessor() {
        return orderProcessor;
    }

    @Override
    public StarterQueue getStarter() {
        return starter;
    }

    @Override
    public List<Security> getSecurities() {
        return securities.getSecurities();
    }

    @Override
    public Security getSecurity(SecurityDescriptor descr)
            throws SecurityException
    {
        return securities.getSecurity(descr);
    }

    @Override
    public boolean isSecurityExists(SecurityDescriptor descr) {
        return securities.isSecurityExists(descr);
    }

    @Override
    public EventType OnSecurityAvailable() {
        return securities.OnSecurityAvailable();
    }

    @Override
    public List<Portfolio> getPortfolios() {
        return portfolios.getPortfolios();
    }

    @Override
    public Portfolio getPortfolio(Account account)
            throws PortfolioException
    {
        return portfolios.getPortfolio(account);
    }

    @Override
    public boolean isPortfolioAvailable(Account account) {
        return portfolios.isPortfolioAvailable(account);
    }

    @Override
    public EventType OnPortfolioAvailable() {
        return portfolios.OnPortfolioAvailable();
    }

    @Override
    public synchronized void start() throws StarterException {
        if ( state == TerminalState.STOPPED ) {
            setTerminalState(TerminalState.STARTING);
            logger.debug("Run start sequence");
            controller.runStartSequence(this);
        } else if ( state == TerminalState.STARTING
                 || state == TerminalState.STOPPING )
        {
            logger.warn("start(): terminal in intermediate state: {}", state);
        } else {
            throw new StarterException("Cannot start terminal: " + state);
        }
    }

    @Override
    public synchronized void stop() throws StarterException {
        if (state == TerminalState.STARTED||state == TerminalState.CONNECTED) {
            setTerminalState(TerminalState.STOPPING);
            logger.debug("Run stop sequence");
            controller.runStopSequence(this);
        } else if ( state == TerminalState.STARTING
                 || state == TerminalState.STOPPING )
        {
            logger.warn("stop(): terminal in intermediate state: {}", state);
        } else {
            throw new StarterException("Cannot stop terminal: " + state);
        }
    }

    @Override
    public Portfolio getDefaultPortfolio()
        throws PortfolioException
    {
        return portfolios.getDefaultPortfolio();
    }

    @Override
    public boolean isOrderExists(int id) {
        return orders.isOrderExists(id);
    }

    @Override
    public List<Order> getOrders() {
        return orders.getOrders();
    }

    @Override
    public Order getOrder(int id) throws OrderException {
        return orders.getOrder(id);
    }

    @Override
    public EventType OnOrderAvailable() {
        return orders.OnOrderAvailable();
    }

    @Override
    public void placeOrder(Order order) throws OrderException {
        synchronized ( order ) {
            OrderStatus status = order.getStatus();
            EditableOrder o = (EditableOrder) order;
            if ( status == OrderStatus.PENDING ) {
                OrderActivator activator = o.getActivator();
                if ( activator != null ) {
                    activator.start(o);
                    o.setStatus(OrderStatus.CONDITION);
                    orders.fireEvents(o);
                    return;
                }
            } else if ( status == OrderStatus.CONDITION ) {
                order.getActivator().stop();
            }
            orderProcessor.placeOrder(this, order);
        }
    }

    @Override
    public synchronized void cancelOrder(Order order) throws OrderException {
        synchronized ( order ) {
            EditableOrder o = (EditableOrder) order;
            OrderStatus status = o.getStatus();
            if ( status == OrderStatus.PENDING ) {
                o.setStatus(OrderStatus.CANCELLED);
                o.setLastChangeTime(getCurrentTime());
                orders.fireEvents(o);
            } else if ( status == OrderStatus.CONDITION ) {
                o.getActivator().stop();
                o.setStatus(OrderStatus.CANCELLED);
                o.setLastChangeTime(getCurrentTime());
                orders.fireEvents(o);
            } else {
                synchronized ( this ) {
                    orderProcessor.cancelOrder(this, order);
                }
            }
        }
    }

    @Override
    public int getOrdersCount() {
        return orders.getOrdersCount();
    }

    @Override
    public EventType OnOrderCancelFailed() {
        return orders.OnOrderCancelFailed();
    }

    @Override
    public EventType OnOrderCancelled() {
        return orders.OnOrderCancelled();
    }

    @Override
    public EventType OnOrderChanged() {
        return orders.OnOrderChanged();
    }

    @Override
    public EventType OnOrderDone() {
        return orders.OnOrderDone();
    }

    @Override
    public EventType OnOrderFailed() {
        return orders.OnOrderFailed();
    }

    @Override
    public EventType OnOrderFilled() {
        return orders.OnOrderFilled();
    }

    @Override
    public EventType OnOrderPartiallyFilled() {
        return orders.OnOrderPartiallyFilled();
    }

    @Override
    public EventType OnOrderRegistered() {
        return orders.OnOrderRegistered();
    }

    @Override
    public EventType OnOrderRegisterFailed() {
        return orders.OnOrderRegisterFailed();
    }

    @Override
    public EventType OnSecurityChanged() {
        return securities.OnSecurityChanged();
    }

    @Override
    public EventType OnSecurityTrade() {
        return securities.OnSecurityTrade();
    }

    @Override
    public EventType OnPortfolioChanged() {
        return portfolios.OnPortfolioChanged();
    }

    @Override
    public EventType OnPositionAvailable() {
        return portfolios.OnPositionAvailable();
    }

    @Override
    public EventType OnPositionChanged() {
        return portfolios.OnPositionChanged();
    }

    @Override
    public int getSecuritiesCount() {
        return securities.getSecuritiesCount();
    }

    @Override
    public int getPortfoliosCount() {
        return portfolios.getPortfoliosCount();
    }

    @Override
    public void fireEvents(EditableOrder order) {
        orders.fireEvents(order);
    }

    @Override
    public EditableOrder getEditableOrder(int id)
        throws OrderNotExistsException
    {
        return orders.getEditableOrder(id);
    }

    @Override
    public void purgeOrder(int id) {
        orders.purgeOrder(id);
    }

    @Override
    public void fireEvents(EditablePortfolio portfolio) {
        portfolios.fireEvents(portfolio);
    }

    @Override
    public EditablePortfolio getEditablePortfolio(Account account) {
        return portfolios.getEditablePortfolio(this, account);
    }

    @Override
    public void setDefaultPortfolio(EditablePortfolio portfolio) {
        portfolios.setDefaultPortfolio(portfolio);
    }

    @Override
    public EditableSecurity getEditableSecurity(SecurityDescriptor descr) {
        return securities.getEditableSecurity(this, descr);
    }

    @Override
    public void fireEvents(EditableSecurity security) {
        securities.fireEvents(security);
    }

    @Override
    public EventType OnConnected() {
        return dispatcher.OnConnected();
    }

    @Override
    public EventType OnDisconnected() {
        return dispatcher.OnDisconnected();
    }

    @Override
    public void fireTerminalConnectedEvent() {
        markTerminalConnected();
    }

    @Override
    public synchronized void markTerminalConnected() {
        if ( state == TerminalState.STARTED ) {
            state = TerminalState.CONNECTED;
            dispatcher.fireConnected(this);
            logger.info("Terminal connected");
        } else {
            logger.debug("Skip connected event request cuz {}", state);
        }
    }

    @Override
    public void fireTerminalDisconnectedEvent() {
        markTerminalDisconnected();
    }

    @Override
    public synchronized void markTerminalDisconnected() {
        if ( state == TerminalState.CONNECTED
          || state == TerminalState.STOPPING )
        {
            if ( state == TerminalState.CONNECTED ) {
                setTerminalState(TerminalState.STARTED);
            }
            dispatcher.fireDisconnected(this);
            logger.info("Terminal disconnected");
        } else {
            logger.debug("Skip disconnected event request cuz {}", state);
        }
    }

    @Override
    public void fireTerminalStartedEvent() {
        dispatcher.fireStarted();
    }

    @Override
    public void fireTerminalStoppedEvent() {
        dispatcher.fireStopped();
    }

    @Override
    public EventType OnStarted() {
        return dispatcher.OnStarted();
    }

    @Override
    public EventType OnStopped() {
        return dispatcher.OnStopped();
    }

    @Override
    public EventType OnPanic() {
        return dispatcher.OnPanic();
    }

    @Override
    public void firePanicEvent(int code, String msgId) {
        firePanicEvent(code, msgId, new Object[] { });
    }

    @Override
    public void firePanicEvent(int code, String msgId, Object[] args) {
        if ( started() ) {
            logger.error("PANIC[" + code + "]: " + msgId, args);
            dispatcher.firePanic(code, msgId, args);
            try {
                stop();
            } catch ( StarterException e ) {
                logger.error("Unexpected exception (ignore): ", e);
            }
        }
    }

    @Override
    public synchronized boolean stopped() {
        return state == TerminalState.STOPPED;
    }

    @Override
    public synchronized boolean connected() {
        return state == TerminalState.CONNECTED;
    }

    @Override
    public synchronized boolean started() {
        return state == TerminalState.CONNECTED
            || state == TerminalState.STARTED;
    }

    @Override
    public synchronized TerminalState getTerminalState() {
        return state;
    }

    @Override
    public synchronized void setTerminalState(TerminalState state) {
        logger.debug("Change terminal state to {}", state);
        this.state = state;
    }

    @Override
    public DateTime getCurrentTime() {
        return scheduler.getCurrentTime();
    }

    @Override
    public EventSystem getEventSystem() {
        return es;
    }

    @Override
    public EditableOrder createOrder() {
        return orders.createOrder(this);
    }

    @Override
    public EventType OnOrderTrade() {
        return orders.OnOrderTrade();
    }

    @Override
    public Order createOrder(Account account, Direction dir, Security security,
            long qty, double price)
    {
        return createOrder(account, dir, security, qty, price, null);
    }

    @Override
    public Order createOrder(Account account, Direction dir, Security security,
            long qty)
    {
        return createOrder(account, dir, security, qty, null);
    }

    @Override
    public Order createOrder(Account account, Direction dir, Security security,
            long qty, double price, OrderActivator activator)
    {
        EditableOrder order = createOrder();
        order.setTime(getCurrentTime());
        order.setType(OrderType.LIMIT);
        order.setAccount(account);
        order.setDirection(dir);
        order.setSecurityDescriptor(security.getDescriptor());
        order.setQty(qty);
        order.setQtyRest(qty);
        order.setPrice(price);
        if ( activator != null ) {
            order.setActivator(activator);
        }
        order.resetChanges();
        orders.fireEvents(order);
        return order;
    }

    @Override
    public Order createOrder(Account account, Direction dir, Security security,
            long qty, OrderActivator activator)
    {
        EditableOrder order = createOrder();
        order.setTime(getCurrentTime());
        order.setType(OrderType.MARKET);
        order.setAccount(account);
        order.setDirection(dir);
        order.setSecurityDescriptor(security.getDescriptor());
        order.setQty(qty);
        order.setQtyRest(qty);
        if ( activator != null ) {
            order.setActivator(activator);
        }
        order.resetChanges();
        orders.fireEvents(order);
        return order;
    }

    @Override
    public void requestSecurity(SecurityDescriptor descr) {

    }

    @Override
    public EventType OnRequestSecurityError() {
        return dispatcher.OnRequestSecurityError();
    }

    @Override
    public void fireSecurityRequestError(SecurityDescriptor descr,
            int errorCode, String errorMsg)
    {
        dispatcher.fireSecurityRequestError(descr, errorCode, errorMsg);
    }

    @Override
    public TaskHandler schedule(Runnable task, DateTime time) {
        return scheduler.schedule(task, time);
    }

    @Override
    public TaskHandler schedule(Runnable task, DateTime firstTime,
            long period)
    {
        return scheduler.schedule(task, firstTime, period);
    }

    @Override
    public TaskHandler schedule(Runnable task, long delay) {
        return scheduler.schedule(task, delay);
    }

    @Override
    public TaskHandler schedule(Runnable task, long delay, long period) {
        return scheduler.schedule(task, delay, period);
    }

    @Override
    public TaskHandler scheduleAtFixedRate(Runnable task, DateTime firstTime,
            long period)
    {
        return scheduler.scheduleAtFixedRate(task, firstTime, period);
    }

    @Override
    public TaskHandler scheduleAtFixedRate(Runnable task, long delay,
            long period)
    {
        return scheduler.scheduleAtFixedRate(task, delay, period);
    }

    @Override
    public void cancel(Runnable task) {
        scheduler.cancel(task);
    }

    @Override
    public boolean scheduled(Runnable task) {
        return scheduler.scheduled(task);
    }

    @Override
    public TaskHandler getTaskHandler(Runnable task) {
        return scheduler.getTaskHandler(task);
    }

    /**
     * Получить планировщик задач.
     * <p>
     * @return планировщик
     */
    public Scheduler getScheduler() {
        return scheduler;
    }

    /**
     * Получить контроллер терминала.
     * <p>
     * @return контроллер терминала
     */
    public TerminalController getTerminalController() {
        return controller;
    }

    /**
     * Получить диспетчер событий терминала.
     * <p>
     * @return диспетчер событий
     */
    public TerminalEventDispatcher getTerminalEventDispatcher() {
        return dispatcher;
    }

    /**
     * Получить хранилище инструментов.
     * <p>
     * @return хранилище инструментов
     */
    public Securities getSecurityStorage() {
        return securities;
    }

    /**
     * Получить хранилище портфелей.
     * <p>
     * @return хранилище портфелей
     */
    public Portfolios getPortfolioStorage() {
        return portfolios;
    }

    /**
     * Получить хранилище заявок.
     * <p>
     * @return хранилище заявок
     */
    public Orders getOrderStorage() {
        return orders;
    }

    @Override
    public EventType OnReady() {
        return dispatcher.OnReady();
    }

    @Override
    public EventType OnUnready() {
        return dispatcher.OnUnready();
    }

    @Override
    public void fireTerminalReady() {
        logger.debug("Terminal marked as ready");
        dispatcher.fireReady();
    }

    @Override
    public void fireTerminalUnready() {
        logger.debug("Terminal marked as unready");
        dispatcher.fireUnready();
    }

    @Override
    public Counter getOrderIdSequence() {
        return orders.getIdSequence();
    }

}