package hib;

import java.util.List;
import javax.servlet.http.HttpSession;
import main.Utils;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.SessionFactory;

/**
 * Hibernate Utility class with a convenient method to get Session Factory object.
 *
 * @author barry
 */
public class HibernateUtil
{

    public static char closeAccountIfPossible(User user)
    {
        char result;
        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            Query q = session.createQuery("from Transaction as transaction "
                    + "where transaction.accountNum=:accountNum order by unixTime desc");
            q.setParameter("accountNum", user.getAccountNum());
            q.setMaxResults(1);
            Transaction lastTransaction = (Transaction) q.uniqueResult();

            long balance = lastTransaction.getBalance();

            // CLOSE ACCOUNT
            if (balance == 0)
            {
                session.delete(user);

                q = session.createQuery("delete from Transaction as transaction "+
                                        "where transaction.accountNum=:accountNum");
                q.setParameter("accountNum", user.getAccountNum());
                q.executeUpdate();

                result = 's';
            }
            else if (balance > 0)
            {
                result = 'g';
            }
            else
            {
                result = 'l';
            }

            session.getTransaction().commit();
            session.close();
        }
        catch (Exception e)
        {
            result = 'e';
        }

        return result;
    }

    public static void main(String[] args)
    {
        char r = deleteRecordsInUserTable();
        System.out.println("r="+r);
    }
    public static char deleteRecordsInUserTable()
    {
        Utils.p("HIBERNATEUTIL, deleteRecordsInUserTable");
        char result;
        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            //Utils.p("HIBENATEUTILS, "+((session==null)?"NULL SESSION":"NOT NULL SESSION"));
            //Utils.p("HIBENATEUTILS A");
            Query q = session.createQuery("delete from User");


            q.executeUpdate();
            q = session.createQuery("delete from Transaction");
            q.executeUpdate();

            //Utils.p("HIBENATEUTILS C");
            result = 'd';

            session.getTransaction().commit();
            session.close();

            //Utils.p("HIBENATEUTILS D");
        }
        catch (Exception e)
        {
            result = 'e';
            Utils.p("HIBENATEUTILS E"+e.getMessage());
        }

        return result;
    }






    Session session = null;
    private static final SessionFactory sessionFactory;

    static
    {
        try
        {
            // Create the SessionFactory from standard (hibernate.cfg.xml)
            // config file.
            sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
        } catch (Throwable ex)
        {
            // Log the exception.
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory()
    {
        return sessionFactory;
    }

    public static boolean addUser(User user)
    {
        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();
            session.save(user);

            session.getTransaction().commit();
            session.close();
        } catch (Exception e)
        {
            return false;
        }

        return true;
    }

    public static List<User> getUsersNotThisAccountNum(String accountNum)
    {
        List<User> users = null;

        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            Query q = session.createQuery("from User as user "
                    + "where user.accountNum != :accountNum");
            q.setParameter("accountNum", accountNum);
            users = q.list();

            session.getTransaction().commit();
            session.close();
        } catch (Exception e)
        {
        }

        return users;
    }



    public static boolean identicalAccountNumberPresent(String generatedAN)
    {
        boolean identicalPresent = false;

        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            Query q = session.createQuery("from User as user "
                    + "where user.accountNum = :accountNum");
            q.setParameter("accountNum", generatedAN);
            if (!q.list().isEmpty())
            {
                identicalPresent = true;
            }

            session.getTransaction().commit();
            session.close();
        } catch (Exception e)
        {
        }

        return identicalPresent;
    }



    public static long getLastBalance(String accountNum) throws Exception
    {
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();

        Query q = session.createQuery("from Transaction as transaction "
                + "where transaction.accountNum=:accountNum order by unixTime desc");
        q.setParameter("accountNum", accountNum);
        q.setMaxResults(1);
        long balance = ((Transaction) q.uniqueResult()).getBalance();

        session.getTransaction().commit();
        session.close();

        return balance;
    }

    public static boolean updateUserAndHttpSessionBean(User user, long desiredOverdraft, HttpSession httpSession)
    {
        boolean userUpdated;
        user.setOverdraft(desiredOverdraft);

        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            session.update(user);
            userUpdated = true;

            session.getTransaction().commit();
            session.close();
        } catch (Exception e)
        {
            userUpdated = false;
        }

        httpSession.setAttribute("USERBEAN", user);

        return userUpdated;
    }

    public static void depositMoney(String accountNum, long plusPence, String message)
    {
        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            Query q = session.createQuery("from Transaction as transaction "
                    + "where transaction.accountNum=:accountNum order by unixTime desc");
            q.setParameter("accountNum", accountNum);
            q.setMaxResults(1);
            Transaction lastTransaction = (Transaction) q.uniqueResult();

            // CREATE NEW TRANSACTION
            Transaction transaction = new Transaction(
                    accountNum,
                    message,
                    plusPence,
                    lastTransaction.getBalance() + plusPence,
                    System.currentTimeMillis());

            session.save(transaction);


            session.getTransaction().commit();
            session.close();
        } catch (Exception e)
        {
        }
    }

    public static char transferMoneyIfPossible(User user, long plusPence, String payeeStr)
    {
        // p = NO PAYEE
        // i = INSUFFICIENT FUNDS
        // t = TRANSFER SUCCESSFUL
        // e = ERROR IN TRANSFER

        char transferResult;

        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            Query q = session.createQuery("from Transaction as transaction "
                    + "where transaction.accountNum = :accountNum order by unixTime desc");
            q.setParameter("accountNum", user.getAccountNum());
            q.setMaxResults(1);
            Transaction lastUserTransaction = (Transaction) q.uniqueResult();

            // SUFFICIENT FUNDS AVAILABLE
            if (lastUserTransaction.getBalance() - plusPence >= -user.getOverdraft())
            {
                // NOW CONFIRM PAYEE STILL EXISTS(MAY HAVE CLOSED ACCOUNT)
                String payeeAN = payeeStr.substring(payeeStr.length() - 9, payeeStr.length() - 1);
                q = session.createQuery("from User as user "
                        + "where user.accountNum=:accountNum");
                q.setParameter("accountNum", payeeAN);
                if (q.uniqueResult() == null)
                {
                    transferResult = 'p';
                } // MAKE TWO TRANSACTIONS
                else
                {
                    long currentTimeMillis = System.currentTimeMillis();

                    // CREATE USER TRANSACTION
                    Transaction userTransaction = new Transaction(
                            user.getAccountNum(),
                            "Transfer to " + payeeStr,
                            -plusPence,
                            lastUserTransaction.getBalance() - plusPence,
                            currentTimeMillis);
                    session.save(userTransaction);


                    // CREATE PAYEE TRANSACTION
                    Query payeeQuery = session.createQuery("from Transaction as transaction "
                            + "where transaction.accountNum=:accountNum order by unixTime desc");
                    payeeQuery.setParameter("accountNum", payeeAN);
                    payeeQuery.setMaxResults(1);
                    Transaction lastPayeeTransaction = (Transaction) q.uniqueResult();
                    Transaction payeeTransaction = new Transaction(
                            payeeAN,
                            "Transfer from " + user.toString(),
                            plusPence,
                            lastPayeeTransaction.getBalance() - plusPence,
                            currentTimeMillis);
                    session.save(payeeTransaction);

                    transferResult = 't';
                }
            } else
            {
                transferResult = 'i';
            }

            session.getTransaction().commit();
            session.close();
        } catch (Exception e)
        {
            transferResult = 'e';
        }

        return transferResult;
    }

    public static boolean withdrawMoneyIfPossible(String accountNum, Long overdraft, long plusPence)
    {
        boolean withdrawn = false;

        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            Query q = session.createQuery("from Transaction as transaction "
                    + "where transaction.accountNum = :accountNum order by unixTime desc");
            q.setParameter("accountNum", accountNum);
            q.setMaxResults(1);
            Transaction lastTransaction = (Transaction) q.uniqueResult();

            if (lastTransaction.getBalance() - plusPence >= -overdraft)
            {
                // CREATE NEW TRANSACTION
                Transaction transaction = new Transaction(
                        accountNum,
                        "Withdrawal",
                        -plusPence,
                        lastTransaction.getBalance() - plusPence,
                        System.currentTimeMillis());

                session.save(transaction);

                withdrawn = true;
            }

            session.getTransaction().commit();
            session.close();
        } catch (Exception e)
        {
            return false;
        }

        return withdrawn;
    }

    public static char changeOverdraftOfPossible(User user, long desiredOverdraft, HttpSession httpSession)
    {
        // 's' SAME OVERDRAFT
        // 'o' OVERDRAFT CHANGED
        // 'i' INVALID OVERDRAFT
        char overdraftResult;

        if (desiredOverdraft == user.getOverdraft())
        {
            overdraftResult = 's';
        }
        else
        {
            if (desiredOverdraft > user.getOverdraft())
            {
                if(updateUserAndHttpSessionBean(user, desiredOverdraft, httpSession)) overdraftResult = 'o';
                else overdraftResult = 'e';
            }
            else // (desiredOverdraft < user.getOverdraft())
            {
                try
                {
                    long balance = getLastBalance(user.getAccountNum());
                    if (balance < -desiredOverdraft)
                    {
                        overdraftResult = 'i';
                    }
                    else
                    {
                        if(updateUserAndHttpSessionBean(user, desiredOverdraft, httpSession)) overdraftResult = 'o';
                        else overdraftResult = 'e';
                    }
                }
                catch (Exception e)
                {
                    overdraftResult = 'e';
                }
            }
        }

        return overdraftResult;
    }


    public static boolean addTransaction(Transaction transaction)
    {
        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            session.save(transaction);


            session.getTransaction().commit();
            session.close();
        } catch (Exception e)
        {
            Utils.pt("HIBERNATEUTILS, addTransaction "+transaction+" "+e.getMessage());
            return false;
        }

        return true;
    }

    public static String getMissingTransactionsString(String accountNum, long lastUnixTime)
    {
        List<Transaction> transactions = getTransactions(accountNum, lastUnixTime);

        String reply = "";

        int len = transactions.size();
        for (int lp = 0; lp < len - 1; lp++)
        {
            reply += transactions.get(lp).toDataString() + "#";
        }
        if (len > 0)
        {
            reply += transactions.get(len - 1).toDataString();
        }

        return reply;
    }

    public static List<Transaction> getTransactions(String accountNum, long unixTime)
    {
        return getTransactions(accountNum, " and unixTime > " + unixTime);
    }

    public static List<Transaction> getTransactions(String accountNum)
    {
        return getTransactions(accountNum, "");
    }

    public static List<Transaction> getTransactions(String accountNum, String extraCondition)
    {
        List<Transaction> transactions = null;

        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();
            Query q = session.createQuery("from Transaction as transaction "
                    + "where transaction.accountNum = :accountNum"
                    + extraCondition);
            q.setParameter("accountNum", accountNum);
            transactions = q.list(); //q.uniqueResult();


            session.getTransaction().commit();
            session.close();

        } catch (Exception e)
        {
        }

        return transactions;
    }

    public static List<User> getUsers()
    {
        List<User> users = null;

        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();
            Query q = session.createQuery("from User as user");
            users = q.list(); //q.uniqueResult();

            session.getTransaction().commit();
            session.close();

        } catch (Exception e)
        {
        }

        return users;
    }

    public static User getUser(String accountNum, String password)
    {
        User user = null;

        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();
            Query q = session.createQuery("from User as user where "
                    + "user.accountNum = :accountNum and "
                    + "user.password = :password");
            q.setParameter("accountNum", accountNum);
            q.setParameter("password", password);
            user = (User) q.uniqueResult();

            session.getTransaction().commit();
            session.close();
        } catch (Exception e)
        {
        }

        return user;
    }

    public static boolean isUserOfEmail(String email)
    {
        boolean existantUser = true;
        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();
            Query q = session.createQuery("from User as user where user.email = :email");
            q.setParameter("email", email);
            existantUser = (q.uniqueResult() != null);

            session.getTransaction().commit();
            session.close();
        } catch (Exception e)
        {
        }

        return existantUser;
    }



    public static Ic getIcObject(String type)
    {
        Ic ic = null;

        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            Query q = session.createQuery("from Ic as ic "
                    + "where ic.type = :type");
            q.setParameter("type", type);
            ic = (Ic)q.uniqueResult();

            session.getTransaction().commit();
            session.close();
        } catch (Exception e)
        {
        }

        return ic;
    }


     public static boolean saveIcObject(Ic ic)
    {
        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            session.update(ic);

            session.getTransaction().commit();
            session.close();
        }
        catch (Exception e)
        {
            return false;
        }
        return true;
    }


      public static void applyIOrCToUser(User user, Ic ic)
    {
        try
        {
            Session session = HibernateUtil.getSessionFactory().openSession();
            session.beginTransaction();

            Query q = session.createQuery("from Transaction as transaction "
                    + "where transaction.accountNum=:accountNum order by unixTime desc");
            q.setParameter("accountNum", user.getAccountNum());
            q.setMaxResults(1);
            Transaction lastTransaction = (Transaction) q.uniqueResult();


            if(lastTransaction.getBalance() > 0 && ic.getType().equals("i"))
                {
                    // ADD pc% INTEREST
                    long amount = (long)(Math.round(lastTransaction.getBalance() * 0.01 * ic.getRate()));

                    if (amount != 0)
                    {

                Transaction transaction = new Transaction(
                        user.getAccountNum(),
                        "Interest: " + ic.getRate() + "%",
                        amount,
                        lastTransaction.getBalance() + amount,
                        System.currentTimeMillis());

                session.save(transaction);
                    }
                }
                else if (lastTransaction.getBalance() < 0 && ic.getType().equals("c"))
                {
                    // DEDUCT pc%
                    long amount = (long)(Math.round(lastTransaction.getBalance() * 0.01 * ic.getRate()));

                    if(amount != 0 && (lastTransaction.getBalance() >= -user.getOverdraft()))
                    {
                        Transaction transaction = new Transaction(
                        user.getAccountNum(),
                        "Overdraft Charge: " + ic.getRate() + "%",
                        amount,
                        lastTransaction.getBalance() + amount,
                        System.currentTimeMillis());

                session.save(transaction);
                    }
                }


            session.getTransaction().commit();
            session.close();
        } catch (Exception e)
        {
        }
    }

}