/*This code was generated using the UMPLE modeling language!
 Date of generation: 2008/07/29 14:36:59*/
/*This class drives: ChargeOccurrence, Suspect, Witness, Victim, InvestigatingOfficer, Jurisdiction*/

package Police.core;

import java.util.*;
import java.sql.Date;
import Police.*;
import Police.json.*;

public class CrimeOccurrence {
  //Class datatypes
  private String location;

  private String date;

  private String time;

  private String description;

  //Class association variables
  private List<ChargeOccurrence> chargeOccurrences;

  private List<Suspect> suspects;

  private List<Witness> witnesss;

  private List<Victim> victims;

  private List<InvestigatingOfficer> investigatingOfficers;

  private List<Jurisdiction> jurisdictions;

  //Registry of our system.
  PoliceRegistry registry = PoliceRegistry.getInstance();

  //Constructor
  public CrimeOccurrence(String aLocation, String aDate, String aTime,
    String aDescription) {
    location = aLocation;
    date = aDate;
    time = aTime;
    description = aDescription;
    chargeOccurrences = new ArrayList<ChargeOccurrence>();
    registry.add(chargeOccurrences);

    suspects = new ArrayList<Suspect>();
    registry.add(suspects);

    witnesss = new ArrayList<Witness>();
    registry.add(witnesss);

    victims = new ArrayList<Victim>();
    registry.add(victims);

    investigatingOfficers = new ArrayList<InvestigatingOfficer>();
    registry.add(investigatingOfficers);

    jurisdictions = new ArrayList<Jurisdiction>();
    registry.add(jurisdictions);

  }

  public boolean setLocation(String aLocation) {
    location = aLocation;
    return true;
  }

  public boolean setDate(String aDate) {
    date = aDate;
    return true;
  }

  public boolean setTime(String aTime) {
    time = aTime;
    return true;
  }

  public boolean setDescription(String aDescription) {
    description = aDescription;
    return true;
  }

  public String getLocation() {
    return location;
  }

  public String getDate() {
    return date;
  }

  public String getTime() {
    return time;
  }

  public String getDescription() {
    return description;
  }

  public List<ChargeOccurrence> getChargeOccurrences() {
    return chargeOccurrences;
  }

  public List<Suspect> getSuspects() {
    return suspects;
  }

  public List<Witness> getWitnesss() {
    return witnesss;
  }

  public List<Victim> getVictims() {
    return victims;
  }

  public List<InvestigatingOfficer> getInvestigatingOfficers() {
    return investigatingOfficers;
  }

  public List<Jurisdiction> getJurisdictions() {
    return jurisdictions;
  }

  public ChargeOccurrence addChargeOccurrence(String aDateEntered,
    String aDisposition, String aPenalty, OffenseType aOffenseType,
    Suspect aSuspect) {
    ChargeOccurrence newChargeOccurrence;
    newChargeOccurrence =
      new ChargeOccurrence(aDateEntered, aDisposition, aPenalty, aOffenseType,
        aSuspect);
    if (!chargeOccurrences.contains(newChargeOccurrence)) {
      registry.add(newChargeOccurrence);
      chargeOccurrences.add(newChargeOccurrence);
    }
    return newChargeOccurrence;
  }

  public ChargeOccurrence addChargeOccurrence(ChargeOccurrence aChargeOccurrence) {
    if (!chargeOccurrences.contains(aChargeOccurrence))
      chargeOccurrences.add(aChargeOccurrence);
    return aChargeOccurrence;
  }

  public Suspect addSuspect(String aName, String aPhone, String aSex,
    String aAddress, String aAge, String aStatement) {
    Suspect newSuspect;
    newSuspect = new Suspect(aName, aPhone, aSex, aAddress, aAge, aStatement);
    if (!suspects.contains(newSuspect)) {
      registry.add(newSuspect);
      suspects.add(newSuspect);
    }
    return newSuspect;
  }

  public Suspect addSuspect(Suspect aSuspect) {
    if (!suspects.contains(aSuspect))
      suspects.add(aSuspect);
    return aSuspect;
  }

  public Witness addWitness(String aName, String aPhone, String aSex,
    String aAddress, String aAge, String aStatement) {
    Witness newWitness;
    newWitness = new Witness(aName, aPhone, aSex, aAddress, aAge, aStatement);
    if (!witnesss.contains(newWitness)) {
      registry.add(newWitness);
      witnesss.add(newWitness);
    }
    return newWitness;
  }

  public Witness addWitness(Witness aWitness) {
    if (!witnesss.contains(aWitness))
      witnesss.add(aWitness);
    return aWitness;
  }

  public Victim addVictim(String aName, String aPhone, String aSex,
    String aAddress, String aAge, String aInjurySuffered) {
    Victim newVictim;
    newVictim =
      new Victim(aName, aPhone, aSex, aAddress, aAge, aInjurySuffered);
    if (!victims.contains(newVictim)) {
      registry.add(newVictim);
      victims.add(newVictim);
    }
    return newVictim;
  }

  public Victim addVictim(Victim aVictim) {
    if (!victims.contains(aVictim))
      victims.add(aVictim);
    return aVictim;
  }

  public InvestigatingOfficer addInvestigatingOfficer(String aName,
    String aPhone, String aSex, String aAddress, String aAge,
    Jurisdiction aJurisdiction) {
    InvestigatingOfficer newInvestigatingOfficer;
    newInvestigatingOfficer =
      new InvestigatingOfficer(aName, aPhone, aSex, aAddress, aAge,
        aJurisdiction);
    if (!investigatingOfficers.contains(newInvestigatingOfficer)) {
      registry.add(newInvestigatingOfficer);
      investigatingOfficers.add(newInvestigatingOfficer);
    }
    return newInvestigatingOfficer;
  }

  public InvestigatingOfficer addInvestigatingOfficer(
    InvestigatingOfficer aInvestigatingOfficer) {
    if (!investigatingOfficers.contains(aInvestigatingOfficer))
      investigatingOfficers.add(aInvestigatingOfficer);
    return aInvestigatingOfficer;
  }

  public Jurisdiction addJurisdiction(String aName, String aPhone,
    String aAddress) {
    Jurisdiction newJurisdiction;
    newJurisdiction = new Jurisdiction(aName, aPhone, aAddress);
    if (!jurisdictions.contains(newJurisdiction)) {
      registry.add(newJurisdiction);
      jurisdictions.add(newJurisdiction);
    }
    return newJurisdiction;
  }

  public Jurisdiction addJurisdiction(Jurisdiction aJurisdiction) {
    if (!jurisdictions.contains(aJurisdiction))
      jurisdictions.add(aJurisdiction);
    return aJurisdiction;
  }

  public void delete() {
    //Delete all many ends first.
    for (ChargeOccurrence aChargeOccurrence : chargeOccurrences) {
      aChargeOccurrence.delete();
    }
    chargeOccurrences.clear();

    //Delete all many ends first.
    for (Suspect aSuspect : suspects) {
      aSuspect.delete();
    }
    suspects.clear();

    //Delete all many ends first.
    for (Witness aWitness : witnesss) {
      aWitness.delete();
    }
    witnesss.clear();

    //Delete all many ends first.
    for (Victim aVictim : victims) {
      aVictim.delete();
    }
    victims.clear();

    //Delete all many ends first.
    for (InvestigatingOfficer aInvestigatingOfficer : investigatingOfficers) {
      aInvestigatingOfficer.delete();
    }
    investigatingOfficers.clear();

    //Delete all many ends first.
    for (Jurisdiction aJurisdiction : jurisdictions) {
      aJurisdiction.delete();
    }
    jurisdictions.clear();

  }

  public void deleteChargeOccurrence(ChargeOccurrence aChargeOccurrence) {

    if (chargeOccurrences.contains(aChargeOccurrence)) {
      chargeOccurrences.remove(aChargeOccurrence);

      //registry.removeObj(registry.getKey(aChargeOccurrence));
    } else
    //Throw an UmpleException .. to be implemented.
    {
    }
  }

  public void deleteSuspect(Suspect aSuspect) {

    if (suspects.contains(aSuspect)) {
      suspects.remove(aSuspect);

      //registry.removeObj(registry.getKey(aSuspect));
    } else
    //Throw an UmpleException .. to be implemented.
    {
    }
  }

  public void deleteWitness(Witness aWitness) {

    if (witnesss.contains(aWitness)) {
      witnesss.remove(aWitness);

      //registry.removeObj(registry.getKey(aWitness));
    } else
    //Throw an UmpleException .. to be implemented.
    {
    }
  }

  public void deleteVictim(Victim aVictim) {

    if (victims.contains(aVictim)) {
      victims.remove(aVictim);

      //registry.removeObj(registry.getKey(aVictim));
    } else
    //Throw an UmpleException .. to be implemented.
    {
    }
  }

  public void deleteInvestigatingOfficer(
    InvestigatingOfficer aInvestigatingOfficer) {

    if (investigatingOfficers.contains(aInvestigatingOfficer)) {
      investigatingOfficers.remove(aInvestigatingOfficer);

      //registry.removeObj(registry.getKey(aInvestigatingOfficer));
    } else
    //Throw an UmpleException .. to be implemented.
    {
    }
  }

  public void deleteJurisdiction(Jurisdiction aJurisdiction) {

    if (jurisdictions.contains(aJurisdiction)) {
      jurisdictions.remove(aJurisdiction);

      //registry.removeObj(registry.getKey(aJurisdiction));
    } else
    //Throw an UmpleException .. to be implemented.
    {
    }
  }

  public boolean areManyEndsNull() {
    if (chargeOccurrences.size() == 0 && suspects.size() == 0
      && witnesss.size() == 0 && victims.size() == 0
      && investigatingOfficers.size() == 0 && jurisdictions.size() == 0) {
      return true;
    } else
      return false;
  }

  /***********************************
   * Returns the attribute list along with the  
   * class ID in JSON format.
   ***********************************/
  public JSONObject getAttributes() throws JSONException {
    JSONObject obj = new JSONObject();
    obj.put("CLASS_ID", registry.getKey(this));
    obj.put("location", getLocation());
    obj.put("date", getDate());
    obj.put("time", getTime());
    obj.put("description", getDescription());
    return obj;
  }

}