package jalview.datamodel.xdb.embl;

import jalview.datamodel.DBRefEntry;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;

import java.util.Iterator;
import java.util.Vector;

public class EmblEntry {
  String accession;
  String version;
  String taxDivision;
  String desc;
  String rCreated;
  String rLastUpdated;
  String lastUpdated;
  Vector keywords;
  Vector refs;
  Vector dbRefs;
  Vector features;
  EmblSequence sequence;
  /**
   * @return the accession
   */
  public String getAccession() {
    return accession;
  }
  /**
   * @param accession the accession to set
   */
  public void setAccession(String accession) {
    this.accession = accession;
  }
  /**
   * @return the dbRefs
   */
  public Vector getDbRefs() {
    return dbRefs;
  }
  /**
   * @param dbRefs the dbRefs to set
   */
  public void setDbRefs(Vector dbRefs) {
    this.dbRefs = dbRefs;
  }
  /**
   * @return the desc
   */
  public String getDesc() {
    return desc;
  }
  /**
   * @param desc the desc to set
   */
  public void setDesc(String desc) {
    this.desc = desc;
  }
  /**
   * @return the features
   */
  public Vector getFeatures() {
    return features;
  }
  /**
   * @param features the features to set
   */
  public void setFeatures(Vector features) {
    this.features = features;
  }
  /**
   * @return the keywords
   */
  public Vector getKeywords() {
    return keywords;
  }
  /**
   * @param keywords the keywords to set
   */
  public void setKeywords(Vector keywords) {
    this.keywords = keywords;
  }
  /**
   * @return the lastUpdated
   */
  public String getLastUpdated() {
    return lastUpdated;
  }
  /**
   * @param lastUpdated the lastUpdated to set
   */
  public void setLastUpdated(String lastUpdated) {
    this.lastUpdated = lastUpdated;
  }
  /**
   * @return the refs
   */
  public Vector getRefs() {
    return refs;
  }
  /**
   * @param refs the refs to set
   */
  public void setRefs(Vector refs) {
    this.refs = refs;
  }
  /**
   * @return the releaseCreated
   */
  public String getRCreated() {
    return rCreated;
  }
  /**
   * @param releaseCreated the releaseCreated to set
   */
  public void setRcreated(String releaseCreated) {
    this.rCreated = releaseCreated;
  }
  /**
   * @return the releaseLastUpdated
   */
  public String getRLastUpdated() {
    return rLastUpdated;
  }
  /**
   * @param releaseLastUpdated the releaseLastUpdated to set
   */
  public void setRLastUpdated(String releaseLastUpdated) {
    this.rLastUpdated = releaseLastUpdated;
  }
  /**
   * @return the sequence
   */
  public EmblSequence getSequence() {
    return sequence;
  }
  /**
   * @param sequence the sequence to set
   */
  public void setSequence(EmblSequence sequence) {
    this.sequence = sequence;
  }
  /**
   * @return the taxDivision
   */
  public String getTaxDivision() {
    return taxDivision;
  }
  /**
   * @param taxDivision the taxDivision to set
   */
  public void setTaxDivision(String taxDivision) {
    this.taxDivision = taxDivision;
  }
  /**
   * @return the version
   */
  public String getVersion() {
    return version;
  }
  /**
   * @param version the version to set
   */
  public void setVersion(String version) {
    this.version = version;
  }

  /**
   * Recover annotated sequences from EMBL file
   * @param noNa don't return nucleic acid sequences 
   * @param sourceDb TODO
   * @param noProtein don't return any translated protein sequences marked in features
   * @return dataset sequences with DBRefs and features - DNA always comes first
   */
  public jalview.datamodel.SequenceI[] getSequences(boolean noNa, boolean noPeptide, String sourceDb) {
    Vector seqs=new Vector();
    Sequence dna=null;
    if (!noNa) {
      dna = new Sequence(sourceDb+"|"+accession, sequence.getSequence());
      dna.setDescription(desc);
      dna.addDBRef(new DBRefEntry(sourceDb, version, accession));
      // TODO: add mapping for parentAccession attribute
      // TODO: transform EMBL Database refs to canonical form
      if (dbRefs!=null)
        for (Iterator i=dbRefs.iterator(); i.hasNext(); dna.addDBRef((DBRefEntry)i.next()));
    }
    for (Iterator i=features.iterator(); i.hasNext(); ) {
      EmblFeature feature = (EmblFeature) i.next();
      if (!noNa) {
        if (feature.dbRefs!=null && feature.dbRefs.size()>0) {
          for (Iterator dbr=feature.dbRefs.iterator(); dbr.hasNext(); dna.addDBRef((DBRefEntry)dbr.next()) )
            ;
        }
      }
      if (feature.getName().equalsIgnoreCase("CDS")) {
        // extract coding region(s)
        jalview.datamodel.Mapping map = null;
        int[] exon=null;
        if (feature.locations!=null && feature.locations.size()>0) {
          for (Iterator locs=feature.locations.iterator();
          locs.hasNext(); ) {
            EmblFeatureLocations loc = (EmblFeatureLocations) locs.next();
            int[] se = loc.getElementRanges();
            if (exon==null) {
              exon=se;
            } else {
              int[] t=new int[exon.length+se.length];
              System.arraycopy(exon, 0, t, 0, exon.length);
              System.arraycopy(se, 0, t, exon.length,se.length);
              exon=t;
            }
          }
        }
        String prseq=null;
        String prname=null;
        String prid=null;
        int prstart=1;
        // get qualifiers
        if (feature.getQualifiers()!=null && feature.getQualifiers().size()>0) {
          for (Iterator quals=feature.getQualifiers().iterator(); quals.hasNext(); ) {
            Qualifier q = (Qualifier) quals.next();
            if (q.getName().equals("translation")) 
            {
              prseq=q.getValue();
            } 
            else
              if (q.getName().equals("protein_id")) 
              {
                prid=q.getValue();
              }
              else
                if (q.getName().equals("codon_start"))
                {
                  prstart = Integer.parseInt(q.getValue());
                }
                else
                  if (q.getName().equals("product")) {
                    prname = q.getValue();
                  }
          }
        }
        Sequence product=null;
        if (prseq!=null && prname!=null && prid!=null) {
          // extract proteins.
          if (!noPeptide) {
            product = new Sequence(sourceDb+"|"+"EMBLCDS|"+prid+"|"+prname, prseq, prstart, prstart+prseq.length()-1);
            product.setDescription("Protein Product from "+sourceDb);
            seqs.add(product);
          }
          // we have everything - create the mapping and perhaps the protein sequence
          map = new jalview.datamodel.Mapping(product, exon, new int[] { prstart, prstart+prseq.length()-1}, 3, 1);
          // add cds feature to dna seq - this may include the stop codon
          for (int xint=0;xint<exon.length; xint+=2) {
            SequenceFeature sf = new SequenceFeature();
            sf.setBegin(exon[xint]);
            sf.setEnd(exon[xint+1]);
            sf.setType(feature.getName());
            sf.setFeatureGroup(jalview.datamodel.DBRefSource.EMBL);
            sf.setDescription("Exon "+(1+xint)+" for protein '"+prname+"' EMBLCDS:"+prid);
            dna.addSequenceFeature(sf);
          }
        }
        // add dbRefs to sequence
        if (feature.dbRefs!=null && feature.dbRefs.size()>0) 
        {
          for (Iterator dbr=feature.dbRefs.iterator(); dbr.hasNext();  ) 
          {
            DBRefEntry ref = (DBRefEntry)dbr.next();
            ref.setSource(jalview.util.DBRefUtils.getCanonicalName(ref.getSource()));
            if (ref.getSource().equals(jalview.datamodel.DBRefSource.UNIPROT)) 
            {
              ref.setMap(map);
            }
            if (product!=null) {
              DBRefEntry pref = new DBRefEntry(ref.getSource(), ref.getVersion(), ref.getAccessionId());
              pref.setMap(null); // reference is direct
            }
            dna.addDBRef(ref);
          }
        }
        
      } else {
        // General feature type.
        if (!noNa) {
          if (feature.dbRefs!=null && feature.dbRefs.size()>0) {
            for (Iterator dbr=feature.dbRefs.iterator(); dbr.hasNext(); dna.addDBRef((DBRefEntry)dbr.next()) )
              ;
          }
        }
      }

    }
    if (!noNa) {
      seqs.add(dna);
    }
    SequenceI[] sqs = new SequenceI[seqs.size()];
    for (int i=0,j=seqs.size();i<j; i++) {
      sqs[i] = (SequenceI) seqs.elementAt(i);
      seqs.set(i, null);
    }
    return sqs;
  }
}