package jalview.io;

import jalview.datamodel.Alignment;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.DBRefEntry;
import jalview.datamodel.DBRefSource;
import jalview.datamodel.Mapping;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.io.xdb.genbank.GenBankFeature;
import jalview.io.xdb.genbank.GenBankLocation;
import jalview.io.xdb.genbank.GenBankLocationPoint;
import jalview.io.xdb.genbank.GenBankLocationRange;
import jalview.io.xdb.genbank.GenBankLocations;
import jalview.io.xdb.genbank.GenBankLocus;
import jalview.io.xdb.genbank.GenBankReference;
import jalview.io.xdb.genbank.GenBankSequence;
import jalview.io.xdb.genbank.GenBankSource;
import jalview.io.xdb.genbank.GenBankVersion;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.List;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.james.mime4j.field.ParsedField;

public class GenBankFile extends AlignFile {
    private static final Logger log = Logger.getLogger(GenBankFile.class.getName());
	private GenBankVersion version = new GenBankVersion();
	private GenBankLocus locus = new GenBankLocus();
	private GenBankSource source = new GenBankSource();
    private static final Pattern patLocation = Pattern.compile("(\\d+)\\.\\.(\\d+)");
    private static final Pattern patLocationComp = Pattern.compile("(complement)\\((\\d+)\\.\\.(\\d+)\\)");
    private static final Pattern patLocus = Pattern.compile("^LOCUS +([a-z|A-Z|0-9|_]+) +([0-9]+) bp ( {3}|ss\\-|ds\\-|ms\\-)([a-z|A-Z|-|\\s]+) ([a-z| ]{8}) ([A-Z| ]{3}) ([0-9]+-[A-Z]+-[0-9]+)");
    private static final Pattern patQualifierKey = Pattern.compile("/(.*?)=");
    private static final Pattern patFeatureKey = Pattern.compile("^\\s{5}([A-Za-z0-9\\_\\']+)\\s+");
    
    private String definition;
    private String accession;
    private String keywords;
    private String dblink;
    private String baseCount;

	private Vector<GenBankFeature> features;
	private Vector<String> comments;
	//Items under origin 
	private Vector<GenBankSequence> sequences;
	private Vector<GenBankReference> references;
	
	private SequenceI genBankSequence;

	public GenBankFile() {
	}

	public GenBankFile(String inFile, String type) throws IOException {
		super(inFile, type);
	}

	public GenBankFile(FileParse source) throws IOException {
		super(source);
	}

	public void initData() {
		super.initData();
		features = new Vector<GenBankFeature>();
		comments = new Vector<String>();
		sequences = new Vector<GenBankSequence>();
		references = new Vector<GenBankReference>();
	}

	public void parse() throws IOException {
		String line;
		boolean featureMode = false;					//FEATURES found
		boolean seqMode = false;						//Parsing Sequences from SOURCE
		boolean referenceMode = false;					//REFERENCE found
		boolean sourceMode = false;						//SOURCE found
		boolean commentMode = false;					//COMMENT found
		boolean parsingAuthors = false;					//Parsing authors (multiline)
		boolean parsingDefinition = false;				//Parsing definition (multiline)
		boolean parsingKeywords = false;				//Parsing keywords (multiline)
		boolean parsingDbLink = false;					//Parsing DBLINK (multiline)
		boolean parsingTitle = false;					//Parsing title (multiline)
		boolean parsingQualifier = false;				//Parsing feature qualifier (multine)
		String currentQualifierName = "";
		GenBankReference reference = null;
		GenBankFeature feature = null;
		List<String> sourceLines = new ArrayList<String>();

		if (this.isValid()){
			
			while ((line = nextLine()) != null) {
				// We only process lines if they have contents within
				if (line.length() == 0)
					continue;
				
				if (line.startsWith("FEATURES")){
					featureMode = true;
					seqMode = false;
					referenceMode = false;
					sourceMode = false;
					commentMode = false;
					feature = new GenBankFeature();
					source = parseSource(sourceLines);
				}
	
				
				if (seqMode) {
					if (!line.startsWith("//")){
						GenBankSequence seq = processSequenceLine(line);
						sequences.add(seq);
					}
					featureMode = false;
					referenceMode = false;
					sourceMode = false;
				}
				
				if (line.startsWith("ORIGIN")){
					if (feature.getType()!=null)
						features.add(feature);
					featureMode = false;
					referenceMode = false;
					sourceMode = false;
					seqMode = true;					
				}
	
				if (featureMode){
					// Process feature line
					if (!line.startsWith("FEATURES") && !line.startsWith("BASE COUNT")){
						//Parse type			
						if (!line.trim().startsWith("/")){							
							Matcher featuresMatch = patFeatureKey.matcher(line);
							if (featuresMatch.find()){
								if (feature.getType()!=null)
									features.add(feature);	//Hay que añadirlo sólo si no se está a mitad de un qualif o una feature
								//It's a feature
								String type = featuresMatch.group(0);
								feature = new GenBankFeature();
								feature.setType(type);							 
								GenBankLocation loc = parserFeatureLocation(feature, line.replace(type,""));
								feature.setLocation(loc);
								parsingQualifier = false;
								continue;
							}else if (parsingQualifier) {					//If not a feature, it's another part of a qualifier
								String qValue = feature.getQualifier(currentQualifierName);
								StringBuffer sb = new StringBuffer().append(qValue).append(ltrim(line));
								feature.updateQualifier(currentQualifierName, sb.toString());
								continue;					
							}
						}else{
							//It's the begining of a qualifier line
							Matcher matcher = patQualifierKey.matcher(line);
							if (matcher.find()){
							    String qName = matcher.group(1);
							    currentQualifierName = qName.replace("/","");
								line = line.replace(qName,"").replace("/", "").replace("=","");
								feature.addQualifier(currentQualifierName, ltrim(line));
								parsingQualifier = true;
								continue;
							}
						}
					}
				}
				// Process REFERENCE line
				if (line.startsWith("REFERENCE")) {
					if (!referenceMode){
						//This is line is the REFERENCE line
						referenceMode = true;
						featureMode = false;
						sourceMode = false;
						seqMode = false;
					}else{
						//We were at referenceMode, then add current reference to the list and create a new one
						references.add(reference);
					}
					reference = new GenBankReference();
					String desc = processReferenceLine(line,"REFERENCE");
					int[] ranges = parseReferenceDescriptor(desc);
					reference.setDescriptor(desc);
					reference.setOrder(ranges[0]);
					reference.setBegin(ranges[1]);
					reference.setEnd(ranges[2]);
					parsingAuthors = false;
					parsingTitle = false;
					continue;
				}
				
				if (line.startsWith("  AUTHORS")){
					if (referenceMode){
						reference.setAuthors(processReferenceLine(line,"AUTHORS"));
						parsingAuthors = true;
						parsingTitle = false;
					}
					 continue;
				}
				if (line.startsWith("  TITLE")){
					if (referenceMode){
						reference.setTitle(processReferenceLine(line,"TITLE"));
						parsingAuthors = false;
						parsingTitle = true;
					}
					 continue;
				}
				if (line.startsWith("  JOURNAL")){
					if (referenceMode){
						reference.setJournal(processReferenceLine(line,"JOURNAL"));
						parsingTitle = false;
						parsingAuthors = false;
					}
					continue;
				}
				if (line.startsWith("   PUBMED")){
					if (referenceMode){
						reference.setPubmed(processReferenceLine(line,"PUBMED"));
						parsingTitle = false;
						parsingAuthors = false;
					}
					 continue;
				}

				if (line.startsWith("   MEDLINE")){
					if (referenceMode){
						reference.setMedline(processReferenceLine(line,"MEDLINE"));
						parsingTitle = false;
						parsingAuthors = false;
					}
					 continue;
				}
				if (line.startsWith("  REMARK")){
					if (referenceMode){
						reference.setRemark(processReferenceLine(line,"REMARK"));
						parsingTitle = false;
						parsingAuthors = false;
					}
					 continue;
				}
				if (line.startsWith("  CONSRTM")){
					if (referenceMode){
						reference.setConsortia(processReferenceLine(line,"CONSRTM"));
						parsingTitle = false;
						parsingAuthors = false;
					}
					 continue;
				}
				
	
				if (line.startsWith("SOURCE")) {
					parsingKeywords = false;
					sourceMode = true;
					commentMode = false;
					if (sourceMode){
						sourceLines.add(line);
					}
					 continue;
				}
				if (line.indexOf("ORGANISM")!=-1) {
					if (sourceMode){
						sourceLines.add(line);
						 continue;
					}
				}
				
				if (line.startsWith("COMMENT")){
					if (reference!=null)
						references.add(reference);
					commentMode = true;
					sourceMode = false;
					referenceMode = false;
					sourceMode = false;
					seqMode = false;
					comments.add(processCommentLine(line));
					 continue;
				}			
				// Process LOCUS line
				if (line.startsWith("LOCUS")) {
					locus = parseLocus(line);
					continue;
				}
				// Process BASE COUNT line
				if (line.startsWith("BASE COUNT")) {
					baseCount = processHeaderLine(line,"BASE COUNT");
					featureMode = false;
					continue;
				}
				// Process DEFINITION line
				if (line.startsWith("DEFINITION")) {
					definition = processHeaderLine(line,"DEFINITION");
					parsingDefinition = true;
					 continue;
				}
				// Process ACCESSION line
				if (line.startsWith("ACCESSION")) {
					accession = processHeaderLine(line,"ACCESSION");
					parsingDefinition = false;
					continue;
				}
				// Process VERSION line
				if (line.startsWith("VERSION")) {
					version = parseVersion(line);
					//headers.put("VERSION", processHeaderLine(line,"VERSION"));
					 continue;
				}
				// Process DBLINK line
				if (line.startsWith("DBLINK")) {
					dblink =  processHeaderLine(line,"DBLINK");
					parsingDbLink = true;
					 continue;
				}
				// Process KEYWORDS line
				if (line.startsWith("KEYWORDS")) {
					keywords = processHeaderLine(line,"KEYWORDS");
					parsingKeywords = true;
					parsingDbLink = false;					
					 continue;
				}				
				if (sourceMode){
					sourceLines.add(line);
					continue;
				}
				if (parsingDefinition){
					StringBuffer sb = new StringBuffer().append(definition).append(line);
					definition = sb.toString();
					continue;
				}
				if (referenceMode && parsingAuthors){
					if (reference!=null){
						StringBuffer authors = new StringBuffer().append(reference.getAuthors()).append(line);						
						reference.setAuthors(authors.toString());
					}
					continue;
				}
				if (referenceMode && parsingTitle){
					if (reference!=null){
						StringBuffer title = new StringBuffer().append(reference.getTitle()).append(line);						
						reference.setTitle(title.toString());
					}
					continue;
				}
				if (parsingKeywords){
					StringBuffer sb = new StringBuffer().append(keywords).append(line);
					keywords = sb.toString();
					continue;					
				}
				if (parsingDbLink){
					StringBuffer sb = new StringBuffer().append(dblink).append(line);
					dblink = sb.toString();
					continue;					
				}
				if (commentMode){
					comments.add(line);
				}
			}
			setEntries();
		}else{
			//File is not valid
			throw new IOException("GenBankFile is not valid.");
		}
	}	

	protected void setEntries(){
	    StringBuffer result = new StringBuffer();
	    //Mapping GenBank info into Jalview data model
	    genBankSequence = new Sequence(accession,DnaUtils.getNucleotidesFromSequenceVector(sequences));
	    //Mapping DBRefEntry
	    DBRefEntry dbRef = new DBRefEntry();
	    dbRef.setSource(DBRefSource.GENBANK);
	    dbRef.setVersion(version == null ? "" : version.toString());
	    dbRef.setAccessionId(accession);
	    // add map to indicate the sequence is a valid coordinate frame for the dbref
	    dbRef.setMap(new Mapping(null, new int[]
	      { 1, genBankSequence.getLength() }, new int[]
	      { 1, genBankSequence.getLength() }, 1, 1));
	    genBankSequence.addDBRef(dbRef);
	    
	    //add header info as non-positional features
	    //add LOCUS
	    SequenceFeature locusF = new SequenceFeature("LOCUS", (locus == null ? "" : locus.toString()), null, 1, genBankSequence.getLength(), DBRefSource.GENBANK);
	    genBankSequence.addSequenceFeature(locusF);
	    //add DEFNITION
	    SequenceFeature defF = new SequenceFeature("DEFINITION", definition, null, 1, genBankSequence.getLength(), DBRefSource.GENBANK);
	    genBankSequence.addSequenceFeature(defF);
	    //add ACCESSION
	    SequenceFeature accessionF = new SequenceFeature("ACCESSION", accession, null, 1, genBankSequence.getLength(), DBRefSource.GENBANK);
	    genBankSequence.addSequenceFeature(accessionF);
	    //add VERSION
	    SequenceFeature versionF = new SequenceFeature("VERSION", (version == null ? "" : version.toString()), null, 1, genBankSequence.getLength(), DBRefSource.GENBANK);
	    genBankSequence.addSequenceFeature(versionF);
	    //add DBLINK
	    SequenceFeature dblinkF = new SequenceFeature("DBLINK", (dblink == null ? "" : dblink.toString()), null, 1, genBankSequence.getLength(), DBRefSource.GENBANK);
	    genBankSequence.addSequenceFeature(dblinkF);
	    //add KEYWORDS
	    SequenceFeature keywordsF = new SequenceFeature("KEYWORDS", keywords, null, 1, genBankSequence.getLength(), DBRefSource.GENBANK);
	    genBankSequence.addSequenceFeature(keywordsF);
	    //add SOURCE
	    SequenceFeature sourceF = new SequenceFeature("SOURCE", (source == null ? "" : source.toString()), null, 1, genBankSequence.getLength(), DBRefSource.GENBANK);
	    genBankSequence.addSequenceFeature(sourceF);
	    //add BASE COUNT
	    SequenceFeature baseCountF = new SequenceFeature("BASE COUNT", (baseCount == null ? "" : baseCount.toString()), null, 1, genBankSequence.getLength(), DBRefSource.GENBANK);
	    genBankSequence.addSequenceFeature(baseCountF);
	    
	    // add literature and database cross references in the file
	    for (GenBankReference gbRef:references){
	    	//They are non-positional features
	    	SequenceFeature refFeature = new SequenceFeature("REFERENCE", gbRef.toString(),null,gbRef.getBegin(),gbRef.getEnd(),DBRefSource.GENBANK);
	    	genBankSequence.addSequenceFeature(refFeature);
	    }
	    //add COMMENTS
	    if (comments.size()>0){
	    	StringBuffer sb = new StringBuffer();
		    for (String comment: comments){
		    	sb.append(comment).append(newline);
		    }
		    SequenceFeature commentF = new SequenceFeature("COMMENT", sb.toString(), null, 1, genBankSequence.getLength(), DBRefSource.GENBANK);
		    genBankSequence.addSequenceFeature(commentF);
	    }
	    //Mapping FEATURES
	    for (GenBankFeature feature:features){
	    	if (feature.getType()!=null){
		    	SequenceFeature sf = new SequenceFeature();
		    	sf.setType(feature.getType());
		    	sf.setDescription(feature.getType());
		    	
		    	sf.setBegin(feature.getLocation()==null ? 0 : feature.getLocation().getMinor());
		    	sf.setEnd(feature.getLocation()==null ? 0 : feature.getLocation().getMajor());
		    	Enumeration<String> names = feature.getQualifiersNames();
		    	while (names.hasMoreElements()){
		    		String qName = names.nextElement();
		    		String qValue = feature.getQualifier(qName);
		    		sf.setValue(qName, qValue);
		    	}
		    	genBankSequence.addSequenceFeature(sf);
	    	}
	    }
	    SequenceI[] parsedSeqs = new SequenceI[1];
	    parsedSeqs[0] = genBankSequence;
	    this.setSeqs(parsedSeqs);
	}
    private GenBankVersion parseVersion(String line) {
        //VERSION U00096.2 GI:48994873
    	if (line.trim().equalsIgnoreCase("VERSION")){
    		return null;
    	}else{
	        GenBankVersion ver = new GenBankVersion();
	        String v = line.substring(11, line.indexOf(" ", 12)).trim();
	        ver.setVersion(v);
	        int posGI = line.indexOf("GI:", 11 + v.length());
	        if (posGI > -1) {
	            ver.setGI(line.substring(posGI));
	        }
	        return ver;
    	}
    }
    
    private GenBankLocus parseLocus(String line){
    	GenBankLocus loc = new GenBankLocus();
        Matcher mat = patLocus.matcher(line);
        if (mat.find()) {
            String name = mat.group(1);
            String len = mat.group(2);
            String strand = mat.group(3);
            String mtype = mat.group(4);
            String linear = mat.group(5);
            String division = mat.group(6);
            String date = mat.group(7);
    	
	        loc.setName(name == null ? "" : name.trim());
	        loc.setSequenceLength(len == null ? 0 : Integer.parseInt(len));
	        loc.setStrand(strand == null ? "" : strand);
	        loc.setMoleculeType(mtype == null ? "" : mtype);
	        loc.setLinearSequence("linear".equals(linear));
	        loc.setDivision(division == null ? "" : division);
	        loc.setModificationDate(date == null ? "" :date);    		
        }
    	return loc;
    }
	private GenBankSource parseSource(List<String> lines){
		StringBuffer sb = new StringBuffer();
		for(String line:lines){
			sb.append(line).append(newline);
		}
        // Source section
        GenBankSource sou = new GenBankSource();
        String aux = sb.toString().substring(11);
        int fim1 = aux.indexOf("\n");
        if (fim1 > -1) {
            sou.setSource(aux.substring(0, fim1));
            int ini2 = aux.indexOf("ORGANISM");
            if (ini2 > -1) {
                fim1 = aux.indexOf("\n", ini2 + 10);
                if (fim1 > -1) {
                    sou.setOrganism(aux.substring(ini2 + 10, fim1));
                    sou.setTaxonomic(aux.substring(fim1).replaceAll("            ", "").replaceAll("\\s+", ""));
                } else {
                    sou.setOrganism(aux);
                }
            }
        } else {
            sou.setSource(aux);
        }	
        return sou;
	}

    /**
     * Possible situations:
     *
     * 467 Points to a single base in the presented sequence 340..565 Points to
     * a continuous range of bases bounded by and including the starting and
     * ending bases &lt;345..500 Indicates that the exact lower boundary point
     * of a feature is unknown. The location begins at some base previous to the
     * first base specified (which need not be contained in the presented
     * sequence) and continues to and includes the ending base &lt;1..888 The
     * feature starts before the first sequenced base and continues to and
     * includes base 888 1..&gt;888 The feature starts at the first sequenced
     * base and continues beyond base 888 102.110 Indicates that the exact
     * location is unknown but that it is one of the bases between bases 102 and
     * 110, inclusive 123^124 Points to a site between bases 123 and 124
     * join(12..78,134..202) Regions 12 to 78 and 134 to 202 should be joined to
     * form one contiguous sequence complement(34..126) Start at the base
     * complementary to 126 and finish at the base complementary to base 34 (the
     * feature is on the strand complementary to the presented strand)
     * complement(join(2691..4571,4918..5163)) Joins regions 2691 to 4571 and
     * 4918 to 5163, then complements the joined segments (the feature is on the
     * strand complementary to the presented strand)
     * join(complement(4918..5163),complement(2691..4571)) Complements regions
     * 4918 to 5163 and 2691 to 4571, then joins the complemented segments (the
     * feature is on the strand complementary to the presented strand)
     * J00194.1:100..202 Points to bases 100 to 202, inclusive, in the entry (in
     * this database) with primary accession number 'J00194'
     * join(1..100,J00194.1:100..202) Joins region 1..100 of the existing entry
     * with the region 100..202 of remote entry J00194
     *
     * @param fea
     * @param localiza
     */
    private GenBankLocation parserFeatureLocation(GenBankFeature fea, String localiza) {
        // remove os espaços, quebra de linhas etc
        String buf = localiza.replaceAll("\\s", "");

        // checks if there is a comma present between ranges
        // complement(100..110),complement(90..100)
        char[] buf2 = buf.toCharArray();
        int abertos = 0;
        java.util.List<String> lista = new java.util.ArrayList<String>();
        int pinicial = 0;
        for (int i = 0; i < buf2.length; i++) {
            if (buf2[i] == '(') {
                abertos++;
            } else if (buf2[i] == ')') {
                abertos--;
            } else if (buf2[i] == ',' && abertos == 0) {
                lista.add(buf.substring(pinicial, i));
                pinicial = i + 1;
            }
        }
        if (lista.size() > 0) {
            lista.add(buf.substring(pinicial));
            GenBankLocations um = new GenBankLocations();
            um.setOperator(GenBankLocations.NONE);
            for (String s : lista) {
                um.getUnits().add(parserFeatureLocation(fea, s));
            }
            fea.setLocation(um);
            return um;
        }

        // trata as funcoes: complement(location,location...),
        // join(location,location...), order(location,location...)
        if (buf.contains("(")) {
        	GenBankLocations um = new GenBankLocations();
            int ini = buf.indexOf("(");
            int fim = buf.lastIndexOf(")");
            String token = buf.substring(0, ini);
            if ("complement".equalsIgnoreCase(token)) {
                String inter = buf.substring(ini + 1, fim);
                GenBankLocation interno = parserFeatureLocation(fea, inter);
                interno.setComplement(true);
                um.setOperator(GenBankLocations.COMPLEMENT);
                um.getUnits().add(interno);
                fea.setLocation(um);
            } else if ("join".equalsIgnoreCase(token)) {
                String inter = buf.substring(ini + 1, fim);
                GenBankLocation interno = parserFeatureLocation(fea, inter);
                um.setOperator(GenBankLocations.JOIN);
                um.getUnits().add(interno);
                fea.setLocation(um);
            } else if ("order".equalsIgnoreCase(token)) {
                String inter = buf.substring(ini + 1, fim);
                GenBankLocation interno = parserFeatureLocation(fea, inter);
                um.setOperator(GenBankLocations.ORDER);
                um.getUnits().add(interno);
                fea.setLocation(um);
            } else {
                log.log(Level.WARNING, "Token desconhecido em location/features - {0}", token);
                String inter = buf.substring(ini + 1, fim);
                fea.setLocation(parserFeatureLocation(fea, inter));
            }
            return fea.getLocation();
        } else {
            // trata quando tiver uma lista de location
            if (buf.contains(",")) {
                String[] partes = buf.split(",");
                GenBankLocations um = new GenBankLocations();
                for (String p : partes) {
                    um.getUnits().add(
                            parserFeatureLocation(fea, p));
                }
                fea.setLocation(um);
                return um;
            } else {
                // trata quando tiver range
                if (buf.contains("..")) {
                    String[] partes = buf.split("\\.\\.");
                    GenBankLocationRange range = new GenBankLocationRange();
                    if (buf.contains(":")) {
                        for (int i = 0; i < partes.length; i++) {
                            int pos = partes[i].indexOf(":");
                            if (pos > 0) {
                                String entry = partes[i].substring(0, pos);
                                partes[i] = partes[i].substring(pos + 1);
                                range.setEntry(entry);
                            }
                        }
                    }
                    GenBankLocationPoint gp0 = (GenBankLocationPoint) parserFeatureLocation(fea, partes[0]);
                    range.setStart(gp0);
                    GenBankLocationPoint gp1 = (GenBankLocationPoint) parserFeatureLocation(fea, partes[1]);
                    range.setEnd(gp1);
                    fea.setLocation(range);
                    return range;
                } else {
                    // trata um ponto
                    // possibilidades consideradas:
                    //      467
                    //      102.110
                    //      123^124
                    //      <345
                    //      >400
                    //      345>
                    //      400<
                    //      ou uma combinacao dessas
                	GenBankLocationPoint gp = new GenBankLocationPoint();
                    if (buf.contains(":")) {
                        int pos = buf.indexOf(":");
                        if (pos > 0) {
                            String entry = buf.substring(0, pos);
                            buf = buf.substring(pos + 1);
                            gp.setEntry(entry);
                        }
                    }
                    int pos = 0;
                    // verifica os simb < e > antes do primeiro numero
                    if (buf.charAt(pos) == '<' || buf.charAt(pos) == '>') {
                        gp.setPrefix(buf.charAt(pos));
                        pos++;
                    }
                    // pega o primeiro numero
                    int ini = pos;
                    while (pos < buf.length() && buf.charAt(pos) >= '0'
                            && buf.charAt(pos) <= '9') {
                        pos++;
                    }
                    if (buf.subSequence(ini, pos).length() < 1) {
                        System.out.println(localiza);
                    }
                    int num = Integer.parseInt(buf.substring(ini, pos));
                    int num2 = num;
                    // o primeiro numero pode ser o unico numero
                    if (pos < buf.length()) {
                        // verifica se tem os sinais < e > apos o primeiro numero
                        if (buf.charAt(pos) == '<' || buf.charAt(pos) == '>') {
                            if (buf.contains(".") || buf.contains("^")) {
                                gp.setPrefix(buf.charAt(pos));
                            } else {
                                gp.setSufix(buf.charAt(pos));
                            }
                            pos++;
                        }

                        // verifica a separacao dos numeros . ou ^
                        if (pos < buf.length()
                                && (buf.charAt(pos) == '.' || buf.charAt(pos) == '^')) {
                            // separação localizada, possibilidade de mais numero
                            gp.setSymbol(buf.charAt(pos));
                            pos++;

                            // verifica os simb < e > antes do segundo numero
                            if (buf.charAt(pos) == '<' || buf.charAt(pos) == '>') {
                                gp.setSufix(buf.charAt(pos));
                                pos++;
                            }

                            // pega o segundo numero
                            ini = pos;
                            while (pos < buf.length() && buf.charAt(pos) >= '0'
                                    && buf.charAt(pos) <= '9') {
                                pos++;
                            }
                            num2 = Integer.parseInt(buf.substring(ini, pos));

                            // verifica os simb < e > após o segundo numero
                            if (pos < buf.length() && (buf.charAt(pos) == '<' || buf.charAt(pos) == '>')) {
                                gp.setSufix(buf.charAt(pos));
                                pos++;
                            }
                        }
                    }
                    gp.setMin(num);
                    gp.setMax(num2);
                    fea.setLocation(gp);
                    return gp;
                }
            }
        }
    }
    
    private int[] parseReferenceDescriptor(String descriptor){
    	// 1 (bases 1 to 1609) 
    	int[] resultado = new int[3];
    	descriptor = descriptor.replace("(bases", ",").replace("to", ",").replace(")", "");
    	String[] args = descriptor.split(",");
    	resultado[0] = Integer.parseInt(args[0].trim());
    	resultado[1] = Integer.parseInt(args[1].trim());
    	resultado[2] = Integer.parseInt(args[2].trim());
    	return resultado;
    }
	private String processReferenceLine(String line, String component){
		int init = line.indexOf(component);
		if (init!=-1){
			 line = line.replace(component,"");
		}
		return line;
	}
	private String processHeaderLine(String line, String header){
		int init = line.indexOf(header);
		if (init!=-1){
			 line = line.replace(header,"");
		}
		return line;
	}

	private GenBankSequence processSequenceLine(String line) {
		GenBankSequence gbs = new GenBankSequence();
		line = ltrim(line);
		String[] args = line.split(" ");
		gbs.setId(Integer.parseInt(args[0]));
		int len = args.length-1;
		Vector<String> seqs = new Vector<String>();
		for (int i=0;i<len;i++)
			seqs.add(args[i+1]);
		gbs.setSequences(seqs);
		return gbs;
	}

	private String processCommentLine(String line){
		int init = line.indexOf("COMMENT");
		if (init!=-1){
			 line = line.replace("COMMENT","");
		}
		return line;
	}
    public String rtrim(String s) {
        int i = s.length()-1;
        while (i >= 0 && Character.isWhitespace(s.charAt(i))) {
            i--;
        }
        return s.substring(0,i+1);
    }

    public String ltrim(String s) {
        int i = 0;
        while (i < s.length() && Character.isWhitespace(s.charAt(i))) {
            i++;
        }
        return s.substring(i);
    }	

    public String print(){
    	StringBuffer out = new StringBuffer();
    	for (SequenceI seq: this.getSeqs()){
    		SequenceFeature[] seqFeatures = seq.getSequenceFeatures();
			boolean featureLinePrinted = false;
    		for(SequenceFeature sf:seqFeatures){
    			if(sf.getType().equals("LOCUS")){
    				out.append(sf.getDescription()).append(newline);    				
    			}else if (sf.getType().equals("DEFINITION")){
    				out.append("DEFINITION  ").append(sf.getDescription()).append(newline);    				
    			}else if (sf.getType().equals("VERSION")){
    				out.append("VERSION     ").append(sf.getDescription()).append(newline);    				
    			}else if (sf.getType().equals("ACCESSION")){
    				out.append("ACCESSION  ").append(sf.getDescription()).append(newline);
    			}else if (sf.getType().equals("DBLINK")){
    				out.append("DBLINK ").append(sf.getDescription()).append(newline);
    			}else if (sf.getType().equals("KEYWORDS")){
    				out.append("KEYWORDS  ").append(sf.getDescription()).append(newline);    				
    			}else if (sf.getType().equals("SOURCE")){
    				out.append("SOURCE      ").append(sf.getDescription()).append(newline);
    			}else if (sf.getType().equals("REFERENCE")){
    				out.append(sf.getDescription()).append(newline);
    			}else if (sf.getType().equals("COMMENT")){
    				out.append("COMMENT     ").append(sf.getDescription()).append(newline);    				
    			}else if (sf.getType().equals("BASE COUNT")){
    				out.append("BASE COUNT     ").append(sf.getDescription()).append(newline);    				
    			}else{
    				if (!featureLinePrinted){
    					out.append("FEATURES             Location/Qualifiers").append(newline);
    					featureLinePrinted = true;
    				}
    				out.append("     ").append(sf.getType()).append("          ").append(sf.getBegin()).append("..").append(sf.getEnd()).append(newline);
    				Hashtable<String,String> qualifiers = sf.otherDetails;
    				if (qualifiers!=null){
	    				Enumeration<String> keys = qualifiers.keys();
	    				while (keys.hasMoreElements()){
	    					String key = keys.nextElement();
	    					String value = qualifiers.get(key);
	    					if (value!=null){
	    						out.append("                     /").append(key).append("=").append(value).append(newline);
	    					}
	    				}
    				}
    			}
    		}
			out.append("ORIGIN").append(newline);
			//We have to divide sequence in groups of 6x10 chars
			String sequenceString = seq.getSequenceAsString();
			int howManyGroups = (int) Math.floor(sequenceString.length()/60);
			for (int i=0;i<=howManyGroups;i++){
				String sequenceSegment = sequenceString.substring(i*60,Math.min((i+1)*60, sequenceString.length()));
				 if ((!"".equals(sequenceSegment) && (sequenceSegment!=null) && (sequenceSegment.length()>0))){
						out.append("        ").append(60*i+1).append(" ");
				 }
				int segmentLength = sequenceSegment.length();
				if (segmentLength>=10){
					out.append(sequenceSegment.substring(0,10)).append(" ");
					if (segmentLength>=20){
						out.append(sequenceSegment.substring(10,20)).append(" ");					
						if (segmentLength>=30){
							out.append(sequenceSegment.substring(20,30)).append(" ");					
							if (segmentLength>=40){
								out.append(sequenceSegment.substring(30,40)).append(" ");					
								if (segmentLength>=50){
									out.append(sequenceSegment.substring(40,50)).append(" ");	
									if (segmentLength<=60){
										out.append(sequenceSegment.substring(50,sequenceSegment.length()));
									}
								}else{
									out.append(sequenceSegment.substring(40,sequenceSegment.length()));
								}
							}else{
								out.append(sequenceSegment.substring(30,sequenceSegment.length()));
							}
						}else{
							out.append(sequenceSegment.substring(20,sequenceSegment.length()));
						}
					}else{
						out.append(sequenceSegment.substring(10,sequenceSegment.length()));
					}
				} else if ((!"".equals(sequenceSegment) && (sequenceSegment!=null) && (sequenceSegment.length()>0))){
					out.append(sequenceSegment);
				}
				out.append(newline);
			}
			out.append("//");
    	}
    	return out.toString();
    }
}