package jalview.io;

import java.io.IOException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import jalview.bin.Cache;
import jalview.datamodel.DBRefEntry;
import jalview.datamodel.DBRefSource;
import jalview.datamodel.FeatureProperties;
import jalview.datamodel.Sequence;
import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.util.DnaUtils;
import jalview.util.MappingUtils;

/**
 * A class that provides selective parsing of the EMBL flatfile format.
 * <p>
 * The initial implementation is limited to extracting fields used by Jalview
 * after fetching an EMBL or EMBLCDS entry:
 * 
 * <pre>
 * accession, version, sequence, xref
 * and (for CDS feature) location, protein_id, product, codon_start, translation
 * </pre>
 * 
 * For a complete parser, it may be best to adopt that provided in
 * https://github.com/enasequence/sequencetools/tree/master/src/main/java/uk/ac/ebi/embl/flatfile
 * (but note this has a dependency on the Apache Commons library)
 * 
 * @author gmcarstairs
 * @see ftp://ftp.ebi.ac.uk/pub/databases/ena/sequence/release/doc/usrman.txt
 * @see ftp://ftp.ebi.ac.uk/pub/databases/embl/doc/FT_current.html
 */
public class EmblFlatFile extends AlignFile // FileParse
{
  private static final String WHITESPACE = "\\s+";

  private String sourceDb;
  
  /*
   * values parsed from the EMBL flatfile record
   */
  private String accession; // from ID (first token)

  private String version; // from ID (second token)

  private int length = 128; // from ID (7th token), with usable default

  private List<DBRefEntry> dbrefs; // from DR and also CDS /db_xref qualifiers

  private String sequenceString; // from SQ lines

  private String translation; // from CDS feature /translation

  private String cdsLocation; // CDS /location raw value

  private int codonStart = 1; // from CDS /codon_start

  private String proteinName; // from CDS /product

  private String proteinId; // from CDS /protein_id

  private Map<String, String> cdsProps; // CDS other qualifiers e.g. 'note'

  /**
   * Constructor
   * @param fp
   * @param sourceId
   * @throws IOException
   */
  public EmblFlatFile(FileParse fp, String sourceId) throws IOException
  {
    super(false, fp); // don't parse immediately
    this.sourceDb = sourceId;
    dbrefs = new ArrayList<>();
    cdsProps = new Hashtable<>();
  }

  /**
   * Parses the flatfile, and if successful, saves as an annotated sequence
   * which may be retrieved by calling {@code getSequence()}
   * 
   * @throws IOException
   */
  public void parse() throws IOException
  {
    String line = nextLine();
    while (line != null)
    {
      if (line.startsWith("ID"))
      {
        line = processID(line);
      }
      else if (line.startsWith("DR"))
      {
        line = processDR(line);
      }
      else if (line.startsWith("SQ"))
      {
        line = processSQ();
      }
      else if (line.startsWith("FT"))
      {
        line = processFT(line);
      }
      else
      {
        line = nextLine();
      }
    }
    assembleSequence();
  }

  /**
   * Extracts and saves the primary accession and version (SV value) from an ID
   * line, or null if not found. Returns the next line after the one processed.
   * 
   * @param line
   * @throws IOException
   */
  String processID(String line) throws IOException
  {
    String[] tokens = line.substring(2).split(";");

    /*
     * first is primary accession
     */
    String token = tokens[0].trim();
    if (!token.isEmpty())
    {
      this.accession = token;
    }

    /*
     * second token is 'SV versionNo'
     */
    if (tokens.length > 1)
    {
      token = tokens[1].trim();
      if (token.startsWith("SV"))
      {
        String[] bits = token.trim().split(WHITESPACE);
        this.version = bits[bits.length - 1];
      }
    }

    /*
     * seventh token is 'length BP'
     */
    if (tokens.length > 6)
    {
      token = tokens[6].trim();
      String[] bits = token.trim().split(WHITESPACE);
      try
      {
        this.length = Integer.valueOf(bits[0]);
      } catch (NumberFormatException e)
      {
        Cache.log.error("bad length read in flatfile, line: " + line);
      }
    }

    return nextLine();
  }

  /**
   * Processes one DR line and saves as a DBRefEntry cross-reference. Returns
   * the line following the line processed.
   * 
   * @param line
   * @throws IOException
   */
  String processDR(String line) throws IOException
  {
    String[] tokens = line.substring(2).split(";");
    if (tokens.length > 1)
    {
      String db = tokens[0].trim();
      String acc = tokens[1].trim();
      if (acc.endsWith("."))
      {
        acc = acc.substring(0, acc.length() - 1);
      }
      this.dbrefs.add(new DBRefEntry(db, "0", acc));
    }

    return nextLine();
  }

  /**
   * Reads and saves the sequence, read from the lines following the SQ line.
   * Whitespace and position counters are discarded. Returns the next line
   * following the sequence data (the next line that doesn't start with
   * whitespace).
   * 
   * @throws IOException
   */
  String processSQ() throws IOException
  {
    StringBuilder sb = new StringBuilder(this.length);
    String line = nextLine();
    while (line != null && line.startsWith(" "))
    {
      line = line.trim();
      String[] blocks = line.split(WHITESPACE);

      /*
       * omit the last block (position counter) on each line
       */
      for (int i = 0; i < blocks.length - 1; i++)
      {
        sb.append(blocks[i]);
      }
      line = nextLine();
    }
    this.sequenceString = sb.toString();

    return line;
  }

  /**
   * Processes an FT line. If it declares a feature type of interest (currently,
   * only CDS is processed), processes all of the associated lines (feature
   * qualifiers), and returns the next line after that, otherwise simply returns
   * the next line.
   * 
   * @param line
   * @return
   * @throws IOException
   */
  String processFT(String line) throws IOException
  {
    String[] tokens = line.split(WHITESPACE);
    if (tokens.length < 3 || !"CDS".equals(tokens[1]))
    {
      return nextLine();
    }

    this.cdsLocation = tokens[2];

    while ((line = nextLine()) != null)
    {
      if (!line.startsWith("FT    ")) // 4 spaces
      {
        // e.g. start of next feature "FT source..."
        break;
      }

      /*
       * extract qualifier, e.g. FT    /protein_id="CAA37824.1"
       */
      int slashPos = line.indexOf('/');
      if (slashPos == -1)
      {
        Cache.log.error("Unexpected EMBL line ignored: " + line);
        continue;
      }
      int eqPos = line.indexOf('=', slashPos + 1);
      if (eqPos == -1)
      {
        Cache.log.error("Unexpected EMBL line ignored: " + line);
        continue;
      }
      String qualifier = line.substring(slashPos + 1, eqPos);
      String value = line.substring(eqPos + 1);
      if (value.startsWith("\"") && value.endsWith("\""))
      {
        value = value.substring(1, value.length() - 1);
      }

      if ("protein_id".equals(qualifier))
      {
        proteinId = value;
      }
      else if ("codon_start".equals(qualifier))
      {
        try
        {
          codonStart = Integer.parseInt(value.trim());
        } catch (NumberFormatException e)
        {
          Cache.log.error("Invalid codon_start in XML for " + this.accession
                  + ": " + e.getMessage());
        }
      }
      else if ("product".equals(qualifier))
      {
        // sometimes name is returned e.g. for V00488
        proteinName = value;
      }
      else if ("translation".equals(qualifier))
      {
        line = readTranslation(value);
      }
      else if (!"".equals(value))
      {
        // throw anything else into the additional properties hash
        cdsProps.put(qualifier, value);
      }
    }
    
    return line;
  }

  /**
   * Reads and saves the CDS translation from one or more lines of the file, and
   * returns the next line after that
   * 
   * @param value
   *          the first line of the translation (likely quoted)
   * @return
   * @throws IOException
   */
  String readTranslation(String value) throws IOException
  {
    StringBuilder sb = new StringBuilder(this.length / 3 + 1);
    sb.append(value.replace("\"", ""));

    String line;
    while ((line = nextLine()) != null)
    {
      if (!line.startsWith("FT    "))
      {
        break; // reached next feature or other input line
      }
      String[] tokens = line.split(WHITESPACE);
      if (tokens.length < 2)
      {
        Cache.log.error("Ignoring bad EMBL line: " + line);
        break;
      }
      if (tokens[1].startsWith("/"))
      {
        break; // next feature qualifier
      }
      sb.append(tokens[1].replace("\"", ""));
    }

    return sb.toString();
  }

  /**
   * Processes the parsed CDS feature data to
   * <ul>
   * <li>add a CDS feature to the sequence for each CDS start-end range</li>
   * <li>create a protein product sequence for the translation</li>
   * <li>create a cross-reference to protein with mapping from dna</li>
   * <li>add any CDS dbrefs to the sequence and to the protein product</li> 
   * </ul>
   * @param SequenceI dna
   */
  void processCDS(SequenceI dna)
  {
    /*
     * parse location into a list of [start, end, start, end] positions
     */
    int[] exons = getCdsRanges(this.accession, this.cdsLocation);
    int exonNumber = 0;
    
    for (int xint = 0; exons != null
            && xint < exons.length - 1; xint += 2)
    {
      int exonStart = exons[xint];
      int exonEnd = exons[xint + 1];
      int begin = Math.min(exonStart, exonEnd);
      int end = Math.max(exonStart, exonEnd);
      exonNumber++;
      String desc = String.format("Exon %d for protein EMBLCDS:%s",
              exonNumber, proteinId);

      SequenceFeature sf = new SequenceFeature("CDS", desc, begin, end, this.sourceDb);
      if (!cdsProps.isEmpty())
      {
        for (Entry<String, String> val : cdsProps.entrySet())
        {
          sf.setValue(val.getKey(), val.getValue());
        }
      }

      sf.setEnaLocation(this.cdsLocation);
      boolean forwardStrand = exonStart <= exonEnd;
      sf.setStrand(forwardStrand ? "+" : "-");
      sf.setPhase(String.valueOf(codonStart - 1));
      sf.setValue(FeatureProperties.EXONPOS, exonNumber);
      sf.setValue(FeatureProperties.EXONPRODUCT, proteinName);

      dna.addSequenceFeature(sf);
    }
  }

  /**
   * Constructs and saves the sequence from parsed components
   */
  void assembleSequence()
  {
    String name = this.accession;
    if (this.sourceDb != null)
    {
      name = this.sourceDb + "|" + name;
    }
    SequenceI seq = new Sequence(name, this.sequenceString);
    for (DBRefEntry dbref : this.dbrefs)
    {
      seq.addDBRef(dbref);
    }
    
    processCDS(seq);
    seq.deriveSequence();
    
    addSequence(seq);
  }

  /**
   * Output (print) is not implemented for EMBL flat file format
   */
  @Override
  public String print(SequenceI[] seqs, boolean jvsuffix)
  {
    return null;
  }

  /**
   * Returns the CDS location as a single array of [start, end, start, end...]
   * positions. If on the reverse strand, these will be in descending order.
   * 
   * @param accession
   * @param location
   * @return
   */
  protected int[] getCdsRanges(String accession, String location)
  {
    if (location == null)
    {
      return new int[] {};
    }

    try
    {
      List<int[]> ranges = DnaUtils.parseLocation(location);
      return MappingUtils.listToArray(ranges);
    } catch (ParseException e)
    {
      Cache.log.warn(
              String.format("Not parsing inexact CDS location %s in ENA %s",
                      location, accession));
      return new int[] {};
    }
  }
}