/*
    kvlsprot_id_acc_mapper
    ======================

    This program requires one argument: The name of a file.
    The file should have swissprot/UniProt format.

    The program will read through the file and print the following
    columns (separated by tabs) to standard output:

        - Uniprot-ID ("ID")
        - accession-number ("AC")
        - boolean column: 't' means that the accession number is the primary
          accession number
          (if the -n argument has been given, the values in the third
          column will be 1/0)

    The output may be used to feed a relational database
    system, so that the two UniProt identifier types may be mapped to
    each other.

    Note that in UniProt, there may be more than one accession number
    associated to an entry. In other words, an ID may have several
    accession numbers. An accession number may be the primary accession
    number for more than one ID(!).

    Compilation on Linux (add "-O2" and "-march=pentiumpro", if you
    want to try to tune it a bit):
    g++ -o kvlsprot_id_acc_mapper kvlsprot_id_acc_mapper.cc

    - Or, if you have trouble running the binary across Linux versions,
    you may perform a static compilation:
    g++ -static -o kvlsprot_id_acc_mapper kvlsprot_id_acc_mapper.cc
*/

/*
    Copyright (C) 2005 Troels Arvin <troels@genome.kvl.dk>.

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
    USA.
*/

#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <cctype>
#include <cstdlib>

#include <libgen.h>
#include <string.h>
#include <getopt.h>

using namespace std;

static void usage(char* arg0) {
    char* progname=basename(arg0);

    cerr << progname << ":" << endl << endl;
    cerr << "Reads through a swissprot/UniProt formatted file." << endl;
    cerr << "Outputs three columns (tab-delimited):" << endl;
    cerr << " - UniProt ID" << endl;
    cerr << " - Accession number" << endl;
    cerr << " - Boolean ('t'/'f'): Is the accession number the primary one?" << endl;
    cerr << "Note that there may be several lines per ID, because an ID" << endl;
    cerr << "may have more than one accession number. If an ID as more " << endl;
    cerr << "than one accession number, one of the accession numbers will" << endl;
    cerr << "be the 'primary' accession number. Unfortunately, it looks" << endl;
    cerr << "like an accession number may actually be the _primary_ accession" << endl;
    cerr << "number for more than one ID(!)." << endl << endl;
    cerr << "Usage:" << endl << basename(progname) << " [-n] <filename>" << endl << endl;
    cerr << "-n      : use numeric booleans, i.e. print 0 instead of 'f', and " <<endl;
    cerr << "          1 instead of 't'" << endl;
    cerr << "filename: name of file containing swissprot-formatted data" << endl <<endl;
    cerr << "Version: $Id: kvlsprot_id_acc_mapper.cc 9 2005-09-21 20:37:54Z troels $" << endl;
    exit(1);
}

// Grab a non-interrupted sequence of letters, digits, or underscores.
std::string get_id(string::const_iterator& begin, const string::const_iterator& end) {
    stringstream ss;
    while (begin!=end && (isalnum(*begin) || '_'==*begin)) {
        ss << *begin;
        begin++;
    }
    return ss.str();
}

void err(const std::stringstream& msg) {
    cerr << msg.str() << endl;
    exit(1);
}

// Output formatting
void print_triplet(
    const string& id,
    const string& acc,
    const bool is_primary,
    const bool numeric_bool
) {
    const string t=numeric_bool ? "1" : "'t'";
    const string f=numeric_bool ? "0" : "'f'";
    cout << id << '\t' << acc << '\t' << (is_primary ? t : f) << endl;
}

// Handle an accession number line:
// For each accession number on the line, print an
// ID,accession,primary/non-primary triple.
void accession(
    const string& id,string::const_iterator& begin,
    const string::const_iterator& end,
    const bool firstline,
    const bool numeric_bool
) {
    bool found_one=0;
    stringstream msg;
    stringstream acc;

    while (begin!=end && isalnum(*begin)) {
        acc.put(*begin);
        begin++;
        found_one=1;
    }

    if (!found_one) {
        msg << "Found no value for AC after ID " << id;
        err(msg);
    }

    print_triplet(id,acc.str(),firstline,numeric_bool);
    // now, are there more accession numbers on this line?
    while (begin!=end) {
        found_one=0;
        acc.str("");

        // run through whitespace, ";", etc
        while (begin!=end && !isalnum(*begin) && '\n'!=*begin) {
            begin++;
        }
        while (begin!=end && isalnum(*begin)) {
            acc.put(*begin);
            found_one=1;
            begin++;
        }
        if (found_one) {
            print_triplet(id,acc.str(),false,numeric_bool);
        }
    }
}

int main(const int argc, char* argv[]) {

    // some declarations
    typedef string::const_iterator iter;
    string id;
    string tag;
    stringstream msg;
    bool found=0;
    bool endtag_found=0;
    iter head;
    iter end;
    string line;

    // arg handling
    char* fname;
    const char* opts="n";
    unsigned int numeric_bool=0;
    int res;
    int req_argc=2;
    while((res=getopt(argc,argv,opts))!=-1) {
        switch(res) {
            case 'n':
                numeric_bool=1;
                req_argc++;
                break;
            default : usage(argv[0]);
        }
    }
    if (req_argc!=argc) { usage(argv[0]); }
    fname=argv[optind];

    // open file
    ifstream is(fname);
    if (!is) {
        msg << "Could not open file " << fname << " for reading";
        err(msg);
    }

    // definition of involved tags
    string idtag("ID   ");
    string acctag("AC   ");
    string endtag("//");

    // Starts before each ID line
    while (getline(is,line)) {

        // what tag?
        tag=line.substr(0,5);

        // skip uninteresting lines
        if (tag!=idtag && tag!=acctag && tag!=endtag) { continue; }

        // sanity check
        if (tag!=idtag) {
            msg << "Got unexpected tag " << tag << "(expected an initial ID tag)";
            err(msg);
        }

        // grab stuff after the 'ID   ' line-starter
        head=line.begin();
        head+=tag.length(); // advance beyond tag (e.g. beyond 'ID   ')
        end=line.end();

        // grab ID
        id=get_id(head,end); // advances head beyond ID value

        // Look for AC tag
        found=0;
        while (!found && getline(is,line)) {
            tag=line.substr(0,5);
            if (tag==idtag || tag==acctag || tag==endtag) { found=1; }
        }
        if (!found) {
            msg << "After ID " << id << ": Reached end of file before finding an AC or end tag";
            err(msg);
        }
        if (tag!=acctag) {
            msg << "After ID " << id << ": Got unexpected tag " << tag << "; expected an AC tag";
            err(msg);
        }

        // grab stuff after the 'AC   ' line-starter
        head=line.begin();
        head+=tag.length();
        end=line.end();
        // handle this AC line
        accession(id,head,end,true,numeric_bool);

        // now, go for another AC line, or an //-line, or end-of-file
        endtag_found=0;
        while (!endtag_found) {
            // look for subsequent AC line, or //
            found=0;
            while (!found && getline(is,line)) {
                tag=line.substr(0,5);
                if (tag==idtag || tag==acctag || tag==endtag) { found=1; }
            }
            if (!found) {
                // ending a file without a "//" tag seems to be allowed
                is.close();
                exit(0);
            }
            if (tag!=acctag && tag!=endtag) {
                msg << "After ID " << id << ": Got unexpected tag " << tag << "; expected an AC or end tag";
                err(msg);
            }

            if (acctag==tag) {
                // a secondary AC line was found
                head=line.begin();
                head+=tag.length(); // advance beyond tag (e.g. beyond 'ID   ')
                end=line.end();
                accession(id,head,end,false,numeric_bool);
            } else {
                endtag_found=1;
            }
        }
    }

    is.close();

    return 0;
}