package agency;

import java.rmi.*;
import java.sql.*;
import java.util.*;
import javax.ejb.*;
import javax.naming.* ;
import javax.sql.*;
import javax.transaction.* ;

import data.*;

public class AdvertiseJobBean implements SessionBean
{
	private JobLocalHome jobHome;
	private SkillLocalHome skillHome;
	private LocationLocalHome locationHome;
	private CustomerLocalHome customerHome;

	private JobLocal job;

	public void updateDetails (String description, String locationName, String[] skillNames) {

		int initialTranStatus = beginTransactionIfRequired();

        if (skillNames == null) {
            skillNames = new String[0];
        }
        List skillList;
        try {
            skillList = skillHome.lookup(Arrays.asList(skillNames));
        } catch(FinderException ex) {
            error("Invalid skill", ex, initialTranStatus); // throws an exception
            return;
        }

        LocationLocal location=null;
        if (locationName != null) {
	        try {
	            location = locationHome.findByPrimaryKey(locationName);
	        } catch(FinderException ex) {
	            error("Invalid location", ex, initialTranStatus); // throws an exception
	            return;
	        }
        }

		job.setDescription(description);
		job.setLocation(location);
		job.setSkills(skillList);

		completeTransactionIfRequired(initialTranStatus);
	}

	public String getRef() {
		int initialTranStatus = beginTransactionIfRequired();

        String ref = job.getRef();

		completeTransactionIfRequired(initialTranStatus);

        return ref;
    }

	public String getCustomer() {
		int initialTranStatus = beginTransactionIfRequired();

        String customer = job.getCustomer();

		completeTransactionIfRequired(initialTranStatus);

        return customer;
    }

	public String getDescription() {
		int initialTranStatus = beginTransactionIfRequired();

		String description = job.getDescription();

		completeTransactionIfRequired(initialTranStatus);

        return description;
	}

	public String getLocation() {
		int initialTranStatus = beginTransactionIfRequired();

        LocationLocal location = job.getLocation();
		String locationName = (location!=null)?location.getName():null;

		completeTransactionIfRequired(initialTranStatus);

        return locationName;
	}

	public String[] getSkills() {
		int initialTranStatus = beginTransactionIfRequired();

		Collection col = job.getSkills();
		String[] res = new String[col.size()];
		int i = 0;
		for(Iterator iter = col.iterator(); iter.hasNext(); ) {
			Object o = iter.next();
			SkillLocal skill = (SkillLocal)o;
			res[i++] = skill.getName();
		}
		completeTransactionIfRequired(initialTranStatus);
		return res;
	}

	// for use in lifecycle methods where there no bean-managed transaction
	private void error (String msg, Exception ex) {
		String s = "AdvertiseJobBean: "+msg + "\n" + ex;
		System.out.println(s);
		throw new EJBException(s,ex);
	}

	// for use in business methods where there is a bean-managed transaction
	private void error (String msg, Exception ex, int initialTranStatus) {
		String s = "AdvertiseJobBean: "+msg + "\n" + ex;
		System.out.println(s);

        try {
			this.ctx.getUserTransaction().setRollbackOnly();
        } catch(Exception ex2) {
            System.out.println("Unable to set transaction for rollback.");
			// not too concerned; the rollback / commit should fail if this has.
        }
		completeTransactionIfRequired(initialTranStatus);


		throw new EJBException(s,ex);
	}

	// EJB methods start here

	public void ejbCreate (String ref, String customerLogin) throws CreateException {
		int initialTranStatus = beginTransactionIfRequired();
		try {
            CustomerLocal customer = customerHome.findByPrimaryKey(customerLogin);
			job = jobHome.findByPrimaryKey(new JobPK(ref,customer.getLogin()));
		}
		catch (FinderException ex) {
			error ("Cannot find Customer or Job: "+ref+","+customerLogin,ex, initialTranStatus);
		}
		completeTransactionIfRequired(initialTranStatus);
	}

	public void ejbActivate(){
	}

	public void ejbPassivate(){
	}

	public void ejbRemove(){
		job = null;
		jobHome = null;
		skillHome = null;
		locationHome = null;
		customerHome = null;
	}

	private SessionContext ctx;

	public void setSessionContext(SessionContext ctx) {
		this.ctx = ctx;
		InitialContext ic = null;
		try {
			ic = new InitialContext();
			jobHome = (JobLocalHome)ic.lookup("java:comp/env/ejb/JobLocal");
			skillHome = (SkillLocalHome)ic.lookup("java:comp/env/ejb/SkillLocal");
			locationHome = (LocationLocalHome)ic.lookup("java:comp/env/ejb/LocationLocal");
			customerHome = (CustomerLocalHome)ic.lookup("java:comp/env/ejb/CustomerLocal");
		}
		catch (NamingException ex) {
			error("Error looking up depended EJB or resource",ex);
		}
	}

	// transaction management helper methods

	private String statusAsString(int status) {
		switch(status) {
        case Status.STATUS_ACTIVE:
			return "STATUS_ACTIVE";
		case Status.STATUS_NO_TRANSACTION:
			return "STATUS_NO_TRANSACTION";
		case Status.STATUS_UNKNOWN:
			return "STATUS_UNKNOWN";
		case Status.STATUS_COMMITTING:
			return "STATUS_COMMITTING";
		case Status.STATUS_MARKED_ROLLBACK:
			return "STATUS_MARKED_ROLLBACK";
		case Status.STATUS_PREPARED:
			return "STATUS_PREPARED";
		case Status.STATUS_PREPARING:
			return "STATUS_PREPARING";
		case Status.STATUS_ROLLING_BACK:
			return "STATUS_ROLLING_BACK";
		case Status.STATUS_COMMITTED:
			return "STATUS_COMMITTED";
		case Status.STATUS_ROLLEDBACK:
			return "STATUS_ROLLEDBACK";
        default:
            return "unknown STATUS (" + status +")";
        }
    }

	private int beginTransactionIfRequired() {

		UserTransaction tran = this.ctx.getUserTransaction();
		// start a new transaction if needed, else just use existing.
        // (simulates trans-attribute of REQUIRED)
        int initialTranStatus;
        try {
	        initialTranStatus = tran.getStatus();
	        switch(initialTranStatus) {
	        case Status.STATUS_ACTIVE:
	            // just use
	            break;
			case Status.STATUS_NO_TRANSACTION:
	            // create
		        try {
			        tran.begin();
		        } catch(NotSupportedException ex) {
		            // shouldn't happen (only thrown if asking for nested exception
	                // and is not supported by the resource manager; not attempting
	                // to do this here).
	                throw new EJBException("Unable to begin transaction", ex);
		        }
	        	break;
			case Status.STATUS_COMMITTING:
			case Status.STATUS_PREPARED:
			case Status.STATUS_PREPARING:
			case Status.STATUS_ROLLING_BACK:
	            throw new EJBException(
	                	"Transaction in progress of completing, status = " +
	                	statusAsString(initialTranStatus));
			case Status.STATUS_MARKED_ROLLBACK:
	            throw new EJBException(
	                	"Transaction marked for rollback, can't be used.");
			case Status.STATUS_COMMITTED:
			case Status.STATUS_ROLLEDBACK:
		         // heuristics probably exist, otherwise status would have returned
	             // NO_TRANSACTION
	            throw new EJBException(
	                	"Current transaction completed, heuristics probably exist; status = " +
	                	statusAsString(initialTranStatus));
			case Status.STATUS_UNKNOWN:
	            // transient condition, shouldn't occur
	        	throw new EJBException("Transaction status unknown, retry.");
	        default:
	        	throw new EJBException(
	            "Transaction status invalid, status = " + statusAsString(initialTranStatus));
			}
        } catch(SystemException ex) {
            throw new EJBException("Unable to begin transaction", ex);
        }

        return initialTranStatus;
    }

	/**
    * expects initialTranStatus to be either STATUS_NO_TRANSACTION or STATUS_ACTIVE;
    * semantics undefined otherwise
    */
	private void completeTransactionIfRequired(int initialTranStatus) {

		UserTransaction tran = this.ctx.getUserTransaction();

		// if transaction was started, then commit / rollback as needed.
        // (simulates trans-attribute of REQUIRED)
		if (initialTranStatus == Status.STATUS_NO_TRANSACTION) {
	        try {
	            if (tran.getStatus() == Status.STATUS_MARKED_ROLLBACK) {
	                tran.rollback();
	            } else {
	                tran.commit();
                }
            } catch(Exception ex) {
                throw new EJBException("Unable to complete transaction", ex);
            }
        }
    }

}