//
// $Id$

package com.threerings.user;

import static com.threerings.user.Log.log;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.google.common.base.Joiner;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.samskivert.io.PersistenceException;
import com.samskivert.jdbc.ConnectionProvider;
import com.samskivert.jdbc.DatabaseLiaison;
import com.samskivert.jdbc.JDBCUtil;
import com.samskivert.jdbc.JORARepository;
import com.samskivert.jdbc.jora.Table;
import com.samskivert.util.ArrayIntSet;
import com.samskivert.util.StringUtil;

/**
 * Provides access to the account actions table.
 *
 * @deprecated Use com.threerings.user.depot.AccountActionRepository instead.
 */
@Deprecated
public class AccountActionRepository extends JORARepository
{
    /**
     * The database identifier used when establishing a database connection.
     * This value being <code>actiondb</code>.
     */
    public static final String ACTION_DB_IDENT = "actiondb";

    /**
     * Creates the repository and prepares it for operation.
     *
     * @param provider the database connection provider.
     */
    public AccountActionRepository (ConnectionProvider provider)
        throws PersistenceException
    {
        super(provider, ACTION_DB_IDENT);

        // figure out whether or not we should be disabled
        execute(new Operation<Void>() {
            public Void invoke (Connection conn, DatabaseLiaison liaison)
                throws SQLException, PersistenceException
            {
                _active = JDBCUtil.tableExists(conn, "ACCOUNT_ACTIONS");
                if (!_active) {
                    log.info("No actions table. Disabling.");
                }
                return null;
            }
        });
    }

    /**
     * Return the list of actions that have not yet been processed by the specified server.
     * Returns all actions if no server name is specified.
     *
     * <em>Note:</em> this method has two side effects: the first time it is called, it will
     * register this server as a action participant (assuming server is non-null) and
     * subsequently, it will call {@link #pruneActions} if it has not done so within the last
     * hour.
     */
    public List<AccountAction> getActions (String server)
        throws PersistenceException
    {
        return getActions(server, Integer.MAX_VALUE);
    }

    /**
     * Return the list of actions that have not yet been processed by the specified server.
     * Returns all actions if no server name is specified.
     *
     * @param maxActions the maximum number of actions to return.
     *
     * <em>Note:</em> this method has two side effects: the first time it is called, it will
     * register this server as a action participant (assuming server is non-null) and
     * subsequently, it will call {@link #pruneActions} if it has not done so within the last
     * hour.
     */
    public List<AccountAction> getActions (String server, int maxActions)
        throws PersistenceException
    {
        if (!_active) {
            return new ArrayList<AccountAction>();
        }

        // look ma, subselects
        String where = "where ACTION_ID NOT IN " +
            "(select ACTION_ID from PROCESSED_ACTIONS " +
            "where SERVER = '" + server + "') limit " + maxActions;
        List<AccountAction> list = loadAll(_atable, where);

        // unjigger the account names
        for (AccountAction action : list) {
            action.accountName = JDBCUtil.unjigger(action.accountName);
        }

        // no fooling around if we are acting in general
        if (StringUtil.isBlank(server)) {
            return list;
        }

        // if this is the first time this method is called, register ourselves
        // with the action system
        long now = System.currentTimeMillis();
        if (_lastActionPrune == 0L) {
            _lastActionPrune = now;
            try {
                registerActionServer(server);
            } catch (PersistenceException pe) {
                log.warning("Failure registering server", "server", server, pe);
            }

        } else if (now - _lastActionPrune > ACTION_PRUNE_INTERVAL) {
            _lastActionPrune = now;
            try {
                pruneActions();
            } catch (PersistenceException pe) {
                log.warning("Failure auto-pruning actions", "server", server, pe);
            }
        }

        return list;
    }

    /**
     * Adds a new action to the repository.
     */
    public void addAction (String accountName, int action)
        throws PersistenceException
    {
        addAction(accountName, null, action, "");
    }

    /**
     * Adds a new action to the repository.
     */
    public void addAction (String accountName, String data, int action)
        throws PersistenceException
    {
        addAction(accountName, data, action, "");
    }

    /**
     * Adds a new action to the repository.
     */
    public void addAction (String accountName, int action, String server)
        throws PersistenceException
    {
        addAction(accountName, null, action, server);
    }

    /**
     * Adds a new action to the repository, with the specified server being marked as already
     * having processed the action.
     */
    public void addAction (String accountName, String data, int action, final String server)
        throws PersistenceException
    {
        if (!_active) {
            log.info("Dropping account action",
                "name", accountName, "data", data, "action", action, "server", server);
            return;
        }

        // create and insert the account action
        final AccountAction aact = new AccountAction();
        aact.accountName = JDBCUtil.jigger(accountName);
        aact.data = data;
        aact.action = action;
        aact.entered = new Timestamp(System.currentTimeMillis());
        aact.actionId = insert(_atable, aact);

        // note that it was processed by this server if appropriate
        if (!StringUtil.isBlank(server)) {
            noteProcessed(aact.actionId, server);
        }
    }

    /**
     * Updates the single specified action to reflect that the specified server has processed it.
     */
    public void updateAction (AccountAction action, String server)
        throws PersistenceException
    {
        updateActions(Collections.singletonList(action), server);
    }

    /**
     * Batch update a list of actions.
     */
    public void updateActions (List<AccountAction> actions, String server)
        throws PersistenceException
    {
        for (int ii = 0, ll = actions.size(); ii < ll; ii++) {
            noteProcessed(actions.get(ii).actionId, server);
        }
    }

    /**
     * Deletes an action from the repository.
     */
    public void deleteAction (final AccountAction action)
        throws PersistenceException
    {
        // delete the action
        delete(_atable, action);

        // and any records indicating it has been processed
        executeUpdate(new Operation<Void>() {
            public Void invoke (Connection conn, DatabaseLiaison liaison)
                throws SQLException, PersistenceException
            {
                Statement stmt = conn.createStatement();
                try {
                    stmt.executeUpdate("delete from PROCESSED_ACTIONS " +
                                       "where ACTION_ID = " + action.actionId);
                } finally {
                    stmt.close();
                }
                return null;
            }
        });
    }

    /**
     * Notes that the specified server has processed the sepecified action.
     */
    public void noteProcessed (final int actionId, final String server)
        throws PersistenceException
    {
        executeUpdate(new Operation<Void>() {
            public Void invoke (Connection conn, DatabaseLiaison liaison)
                throws SQLException, PersistenceException
            {
                Statement stmt = conn.createStatement();
                try {
                    String query = "insert into PROCESSED_ACTIONS " +
                        "values(" + actionId + ", '" + server + "')";
                    stmt.executeUpdate(query);
                } finally {
                    JDBCUtil.close(stmt);
                }
                return null;
            }
        });
    }

    /**
     * Prunes actions that have been processed by all registered servers to keep the actions table
     * small. This method need not be called by hand as it is called automatically by
     * {@link #getActions(String,int)}, but no more frequently than once an hour.
     */
    public void pruneActions ()
        throws PersistenceException
    {
        final Set<String> servers = loadActionServers();
        executeUpdate(new Operation<Void>() {
            public Void invoke (Connection conn, DatabaseLiaison liaison)
                throws SQLException, PersistenceException
            {
                Map<Integer,Set<String>> procmap = Maps.newHashMap();
                ArrayIntSet actids = new ArrayIntSet();
                Statement stmt = conn.createStatement();
                try {
                    // determine which servers have processed which actions
                    ResultSet rs = stmt.executeQuery(
                        "select ACTION_ID, SERVER from PROCESSED_ACTIONS");
                    while (rs.next()) {
                        Integer actionId = (Integer)rs.getObject(1);
                        Set<String> procset = procmap.get(actionId);
                        if (procset == null) {
                            procmap.put(actionId, procset = Sets.newHashSet());
                        }
                        procset.add(rs.getString(2));
                    }

                    // determine which of those have been fully processed
                    for (Map.Entry<Integer,Set<String>> entry : procmap.entrySet()) {
                        Integer actionId = entry.getKey();
                        Set<String> procset = entry.getValue();
                        if (procset.containsAll(servers)) {
                            actids.add(actionId.intValue());
                        }
                    }

                    // now wipe out the actions (and processed entries) for
                    // all actions that have been fully processed
                    if (actids.size() > 0) {
                        String where = "where ACTION_ID in " +
                            "(" + Joiner.on(",").join(actids) + ")";
                        stmt.executeUpdate("delete from ACCOUNT_ACTIONS " + where);
                        stmt.executeUpdate("delete from PROCESSED_ACTIONS " + where);
                    }
                } finally {
                    JDBCUtil.close(stmt);
                }
                return null;
            }
        });
    }

    /**
     * Registers a server with the action system. This method is called automatically the first
     * time {@link #getActions(String)} is called.
     */
    protected void registerActionServer (final String server)
        throws PersistenceException
    {
        // see if we're already registered
        Set<String> set = loadActionServers();
        if (set.contains(server)) {
            return;
        }

        // if not, insert ourselves into the action table
        executeUpdate(new Operation<Void>() {
            public Void invoke (Connection conn, DatabaseLiaison liaison)
                throws SQLException, PersistenceException
            {
                String query = "insert into ACTION_SERVERS (SERVER) values (?)";
                PreparedStatement stmt = null;
                try {
                    stmt = conn.prepareStatement(query);
                    stmt.setString(1, server);
                    stmt.executeUpdate();

                    return null;
                } finally {
                    JDBCUtil.close(stmt);
                }
            }
        });

        log.info("Registered action server '" + server + "'.");
    }

    /**
     * Loads up the set of action servers.
     */
    protected Set<String> loadActionServers ()
        throws PersistenceException
    {
        return execute(new Operation<Set<String>>() {
            public Set<String> invoke (Connection conn, DatabaseLiaison liaison)
                throws SQLException, PersistenceException
            {
                Set<String> set = Sets.newHashSet();
                String query = "select * from ACTION_SERVERS";
                Statement stmt = null;
                try {
                    stmt = conn.createStatement();
                    ResultSet rs = stmt.executeQuery(query);
                    while (rs.next()) {
                        set.add(rs.getString(1));
                    }
                } finally {
                    JDBCUtil.close(stmt);
                }
                return set;
            }
        });
    }

    @Override
    protected void createTables ()
    {
        _atable = new Table<AccountAction>(AccountAction.class, TABLE, "ACTION_ID", true);
    }

    /** The table used to note actions that have taken place. */
    protected Table<AccountAction> _atable;

    /** Whether or not we're actually being used. */
    protected boolean _active;

    /** Used by {@link #getActions(String)}. */
    protected long _lastActionPrune;

    /** We automatically prune the actions table once an hour. */
    protected static final long ACTION_PRUNE_INTERVAL = 60 * 60 * 1000L;

    /** The name of the account actions table. */
    protected static final String TABLE = "ACCOUNT_ACTIONS";
}