#include "MlpObjectives.hpp"
#include "Utils.hpp"

#include <string>
#include <vector>
#include <stdexcept>
#include <algorithm>
using namespace std;

/* FIXME: (exception handling) Should check for unknown/unimplemented
   definition strings. */

static
bool in(const vector<string> &vec, const string & str){
    return find(vec.begin(), vec.end(), str) != vec.end();
}

string mnemonic(MlpObjKind k){
    switch(k){
    case okind::cwmse:
        return "cwmse";
    case okind::cwmee:
        return "cwmee";
    case okind::cwmae:
        return "cwmae";
    case okind::cwerr:
        return "cwerr";
    case okind::mse:
        return "mse";
    case okind::mee:
        return "mee";
    case okind::mae:
        return "mae";
    case okind::err:
        return "err";
    case okind::mincwmse:
        return "mincwmse";
    case okind::mincwmee:
        return "mincwmee";
    case okind::mincwmae:
        return "mincwmae";
    case okind::mincwe:
        return "mincwe";
    case okind::msw:
        return "msw";
    case okind::mswnb:
        return "mswnb";
    case okind::maw:
        return "maw";
    case okind::mawnb:
        return "mawnb";
    case okind::nhid:
        return "nhid";
    case okind::nnzw:
        return "nnzw";
    case okind::ninput:
        return "ninput";
    case okind::vsmse:
        return "vsmse";
    case okind::vsmee:
        return "vsmee";
    case okind::vsmae:
        return "vsmae";
    case okind::vserr:
        return "vserr";
    default:
        throw runtime_error("Unknown mnemonic requested");
    }
}

static
string classwiseName(MlpObjKind k, size_t c){
    switch(k){
    case okind::cwmse:
        return "Train set MSE error on class "+ to_string(c);
    case okind::cwmee:
        return "Train set MEE error on class "+ to_string(c);
    case okind::cwmae:
        return "Train set MAE error on class "+ to_string(c);
    case okind::cwerr:
        return "Train set error rate on class "+ to_string(c);
    default:
        throw runtime_error("Unknown objective kind");
    }
}

static
string singularName(MlpObjKind k){
    switch(k){
    case okind::mse:      return "MSE over whole training data";
    case okind::mee:      return "MEE over whole training data";
    case okind::mae:      return "MAE over whole training data";
    case okind::err:      return "Error rate over whole training data";
    case okind::mincwmse: return "Minimum of classwise MSEs";
    case okind::mincwmee: return "Minimum of classwise MEEs";
    case okind::mincwmae: return "Minimum of classwise MAEs";
    case okind::mincwe:   return "Minimum of classwise error rates";
    case okind::msw:      return "Mean of squares of all weights";
    case okind::mswnb:    return "Mean of squares of weights except output layer biases";
    case okind::maw:      return "Mean of abs value of all weights";
    case okind::mawnb:    return "Mean of abs value of weights except output layer biases";
    case okind::nhid:     return "Number of hidden neurons";
    case okind::nnzw:     return "Number of non-zero weights";
    case okind::ninput:   return "Number of active input nodes";
    case okind::vsmse: return "Not yet implemented: validation set objs";
    case okind::vsmee: return "Not yet implemented: validation set objs";
    case okind::vsmae: return "Not yet implemented: validation set objs";
    case okind::vserr: return "Not yet implemented: validation set objs";
    default:
        throw runtime_error("Unknown mnemonic requested");
    }
}

void
MlpObjectives::addKindIfInList(const vector<string> & spl, MlpObjKind k, size_t nclasses){
    if (in(spl,mnemonic(k))){
        if (k & (okind::cwmse|okind::cwmee|okind::cwmse|okind::cwerr)){
            // Classwise:
            _evokinds = _evokinds | k;
            for(size_t c=1;c<=nclasses;++c){
                _objname.push_back(classwiseName(k,c));
            }
            _nobj += nclasses;
        } else {
            // Overall:
            _evokinds = _evokinds | k;
            _objname.push_back(singularName(k));
            _nobj += 1;
        }
    }
}

/** Objective function definitions for our MLP individuals. */
MlpObjectives::MlpObjectives(const string & defstr, size_t nclasses){
    vector<string> spl=split(defstr,';');

    _nobj = 0;
    _evokinds = okind::None;

    /* We order our functions (at least as of yet) to keep objective
     * indices simpler. This is done only once, so performance is not
     * a factor.
     */
    addKindIfInList(spl, okind::cwmse, nclasses);
    addKindIfInList(spl, okind::cwmee, nclasses);
    addKindIfInList(spl, okind::cwmae, nclasses);
    addKindIfInList(spl, okind::cwerr, nclasses);
    addKindIfInList(spl, okind::mse, nclasses);
    addKindIfInList(spl, okind::mee, nclasses);
    addKindIfInList(spl, okind::mae, nclasses);
    addKindIfInList(spl, okind::err, nclasses);
    addKindIfInList(spl, okind::mincwmse, nclasses);
    addKindIfInList(spl, okind::mincwmee, nclasses);
    addKindIfInList(spl, okind::mincwmae, nclasses);
    addKindIfInList(spl, okind::mincwe, nclasses);
    addKindIfInList(spl, okind::msw, nclasses);
    addKindIfInList(spl, okind::mswnb, nclasses);
    addKindIfInList(spl, okind::maw, nclasses);
    addKindIfInList(spl, okind::mawnb, nclasses);
    addKindIfInList(spl, okind::nhid, nclasses);
    addKindIfInList(spl, okind::nnzw, nclasses);
    addKindIfInList(spl, okind::ninput, nclasses);
    addKindIfInList(spl, okind::vsmse, nclasses);
    addKindIfInList(spl, okind::vsmee, nclasses);
    addKindIfInList(spl, okind::vsmae, nclasses);
    addKindIfInList(spl, okind::vserr, nclasses);

    if (_nobj == 0){
        throw runtime_error("No objectives defined by string:" + defstr);
    }
}

size_t MlpObjectives::nobj() const{
    return _nobj;
}

string MlpObjectives::name(size_t ind) const{
    return _objname[ind];
}

MlpObjKind MlpObjectives::kinds() const{
    return _evokinds;
}