/**
 *  @file ct.cpp
 *   Cantera interface library. This library of functions is designed
 *   to encapsulate Cantera functionality and make it available for
 *   use in languages and applications other than C++. A set of
 *   library functions is provided that are declared "extern C". All
 *   Cantera objects are stored and referenced by integers - no
 *   pointers are passed to or from the calling application.
 */

#define CANTERA_USE_INTERNAL
#include "ct.h"

// Cantera includes
#include "cantera/equil/equil.h"
#include "cantera/kinetics/KineticsFactory.h"
#include "cantera/transport/TransportFactory.h"
#include "cantera/base/ctml.h"
#include "cantera/kinetics/importKinetics.h"
#include "cantera/thermo/ThermoFactory.h"
#include "converters/ck2ct.h"
#include "Storage.h"
#include "Cabinet.h"
#include "cantera/kinetics/InterfaceKinetics.h"
#include "cantera/thermo/PureFluidPhase.h"


using namespace std;
using namespace Cantera;

#ifdef _WIN32
#include "windows.h"
#endif

typedef Cabinet<XML_Node, false> XmlCabinet;

#ifdef WITH_PURE_FLUIDS
static PureFluidPhase* purefluid(int n)
{
    try {
        ThermoPhase* tp = th(n);
        if (tp->eosType() == cPureFluid) {
            return (PureFluidPhase*)tp;
        } else {
            throw CanteraError("purefluid","object is not a PureFluidPhase object");
        }
    } catch (CanteraError) {
        return 0;
    }
    return 0;
}

static double pfprop(int n, int i, double v=0.0, double x=0.0)
{
    PureFluidPhase* p = purefluid(n);
    if (p) {
        switch (i) {
        case 0:
            return p->critTemperature();
        case 1:
            return p->critPressure();
        case 2:
            return p->critDensity();
        case 3:
            return p->vaporFraction();
        case 4:
            return p->satTemperature(v);
        case 5:
            return p->satPressure(v);
        case 6:
            p->setState_Psat(v, x);
            return 0.0;
        case 7:
            p->setState_Tsat(v, x);
            return 0.0;
        }
    }
    return DERR;
}


#else

static ThermoPhase* purefluid(int n)
{
    return th(n);
}
static double pfprop(int n, int i, double v=0.0, double x=0.0)
{
    return DERR;
}
#endif


inline size_t nThermo()
{
    return Storage::storage()->nThermo();
}

namespace Cantera
{
void writephase(const ThermoPhase& th, bool show_thermo);
}

/**
 * Exported functions.
 */
extern "C" {

#ifdef _WIN32
#ifndef NO_DLL_BUILD
    /*
    *  The microsoft docs says we may need this in some
    *  cases when building dll's
    */
    /*
    bool  WINAPI DllMain(HINSTANCE hModule,
                DWORD  ul_reason_for_call,
                      LPVOID lpReserved) {
    switch(ul_reason_for_call ) {
    case DLL_PROCESS_ATTACH:
    break;
    case DLL_THREAD_ATTACH:
    break;
    case DLL_THREAD_DETACH:
    break;
    case DLL_PROCESS_DETACH:
    break;
    }
    return TRUE;
    }
    */
#endif
#endif

    int DLL_EXPORT ct_appdelete()
    {
        appdelete();
        return 0;
    }

    //--------------- Phase ---------------------//

    size_t DLL_EXPORT phase_nElements(int n)
    {
        return ph(n)->nElements();
    }

    size_t DLL_EXPORT phase_nSpecies(int n)
    {
        return ph(n)->nSpecies();
    }

    doublereal DLL_EXPORT phase_temperature(int n)
    {
        return ph(n)->temperature();
    }

    int DLL_EXPORT phase_setTemperature(int n, double t)
    {
        try {
            ph(n)->setTemperature(t);
        } catch (CanteraError) {
            return -1;
        }
        return 0;
    }

    doublereal DLL_EXPORT phase_density(int n)
    {
        return ph(n)->density();
    }

    int DLL_EXPORT phase_setDensity(int n, double rho)
    {
        if (rho < 0.0) {
            return -1;
        }
        ph(n)->setDensity(rho);
        return 0;
    }

    doublereal DLL_EXPORT phase_molarDensity(int n)
    {
        return ph(n)->molarDensity();
    }

    int DLL_EXPORT phase_setMolarDensity(int n, double ndens)
    {
        if (ndens < 0.0) {
            return -1;
        }
        ph(n)->setMolarDensity(ndens);
        return 0;
    }

    doublereal DLL_EXPORT phase_meanMolecularWeight(int n)
    {
        return ph(n)->meanMolecularWeight();
    }

    size_t DLL_EXPORT phase_elementIndex(int n, char* nm)
    {
        string elnm = string(nm);
        return ph(n)->elementIndex(elnm);
    }

    size_t DLL_EXPORT phase_speciesIndex(int n, char* nm)
    {
        string spnm = string(nm);
        return ph(n)->speciesIndex(spnm);
    }

    int DLL_EXPORT phase_getMoleFractions(int n, size_t lenx, double* x)
    {
        ThermoPhase* p = ph(n);
        if (lenx >= p->nSpecies()) {
            p->getMoleFractions(x);
            return 0;
        } else {
            return -1;
        }
    }

    doublereal DLL_EXPORT phase_moleFraction(int n, size_t k)
    {
        ThermoPhase* p = ph(n);
        return p->moleFraction(k);
    }

    int DLL_EXPORT phase_getMassFractions(int n, size_t leny, double* y)
    {
        ThermoPhase* p = ph(n);
        if (leny >= p->nSpecies()) {
            p->getMassFractions(y);
            return 0;
        } else {
            return -1;
        }
    }

    doublereal DLL_EXPORT phase_massFraction(int n, size_t k)
    {
        ThermoPhase* p = ph(n);
        return p->massFraction(k);
    }

    int DLL_EXPORT phase_setMoleFractions(int n, size_t lenx, double* x, int norm)
    {
        ThermoPhase* p = ph(n);
        if (lenx >= p->nSpecies()) {
            if (norm) {
                p->setMoleFractions(x);
            } else {
                p->setMoleFractions_NoNorm(x);
            }
            return 0;
        } else {
            return -1;
        }
    }

    int DLL_EXPORT phase_setMoleFractionsByName(int n, char* x)
    {
        try {
            ThermoPhase* p = ph(n);
            compositionMap xx;
            size_t nsp = p->nSpecies();
            for (size_t n = 0; n < nsp; n++) {
                xx[p->speciesName(n)] = -1;
            }
            parseCompString(string(x), xx);
            p->setMoleFractionsByName(xx);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
        //catch (...) {return ERR;}
    }

    int DLL_EXPORT phase_setMassFractions(int n, size_t leny,
                                          double* y, int norm)
    {
        ThermoPhase* p = ph(n);
        if (leny >= p->nSpecies()) {
            if (norm) {
                p->setMassFractions(y);
            } else {
                p->setMassFractions_NoNorm(y);
            }
            return 0;
        } else {
            return -10;
        }
    }

    int DLL_EXPORT phase_setMassFractionsByName(int n, char* y)
    {
        try {
            ThermoPhase* p = ph(n);
            compositionMap yy;
            size_t nsp = p->nSpecies();
            for (size_t n = 0; n < nsp; n++) {
                yy[p->speciesName(n)] = -1;
            }
            parseCompString(string(y), yy);
            p->setMassFractionsByName(yy);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT phase_getAtomicWeights(int n,
                                          size_t lenm, double* atw)
    {
        ThermoPhase* p = ph(n);
        if (lenm >= p->nElements()) {
            const vector_fp& wt = p->atomicWeights();
            copy(wt.begin(), wt.end(), atw);
            return 0;
        } else {
            return -10;
        }
    }

    int DLL_EXPORT phase_getMolecularWeights(int n,
            size_t lenm, double* mw)
    {
        ThermoPhase* p = ph(n);
        if (lenm >= p->nSpecies()) {
            const vector_fp& wt = p->molecularWeights();
            copy(wt.begin(), wt.end(), mw);
            return 0;
        } else {
            return -10;
        }
    }

    int DLL_EXPORT phase_getName(int n, size_t lennm, char* nm)
    {
        string name = ph(n)->name();
        size_t lout = min(lennm, name.size());
        copy(name.c_str(), name.c_str() + lout, nm);
        nm[lout] = '\0';
        return 0;
    }

    int DLL_EXPORT phase_setName(int n, const char* nm)
    {
        string name = string(nm);
        ph(n)->setName(name);
        return 0;
    }

    int DLL_EXPORT phase_getSpeciesName(int n, size_t k, size_t lennm, char* nm)
    {
        try {
            string spnm = ph(n)->speciesName(k);
            size_t lout = min(lennm, spnm.size());
            copy(spnm.c_str(), spnm.c_str() + lout, nm);
            nm[lout] = '\0';
            return 0;
        } catch (CanteraError) {
            return -1;
        }
        //catch (...) {return ERR;}
    }

    int DLL_EXPORT phase_getElementName(int n, size_t m, size_t lennm, char* nm)
    {
        try {
            string elnm = ph(n)->elementName(m);
            size_t lout = min(lennm, elnm.size());
            copy(elnm.c_str(), elnm.c_str() + lout, nm);
            nm[lout] = '\0';
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }


    doublereal DLL_EXPORT phase_nAtoms(int n, size_t k, size_t m)
    {
        try {
            return ph(n)->nAtoms(k,m);
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT phase_addElement(int n, char* name, doublereal weight)
    {
        try {
            ph(n)->addElement(string(name),weight);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    //     int DLL_EXPORT phase_addSpecies(int n, char* name, int phase,
    //         int ncomp, doublereal* comp, int thermoType, int ncoeffs,
    //         double* coeffs, double minTemp, double maxTemp, double refPressure,
    //         doublereal charge, doublereal weight) {
    //         try {
    //             vector_fp cmp(ncomp);
    //             copy(comp, comp + ncomp, cmp.begin());
    //             vector_fp c(ncoeffs);
    //             copy(coeffs, coeffs + ncoeffs, c.begin());
    //             ph(n)->addSpecies(string(name), phase, cmp,
    //                 thermoType, c, minTemp, maxTemp, refPressure,
    //                 charge, weight);
    //             return 0;
    //         }
    //         catch (CanteraError) { return -1; }
    //         catch (...) {return ERR;}
    //     }



    //-------------- Thermo --------------------//

    //    int DLL_EXPORT newThermo(int eos, int ph, int sptherm) {
    //    return Storage::storage()->addNewThermo(eos, ph, sptherm);
    // }

    int DLL_EXPORT th_thermoIndex(char* id)
    {
        return thermo_index(id);
    }

    //     int DLL_EXPORT newThermo(char* model) {
    //         try {
    //             string m = string(model);
    //             thermo_t* th = newThermoPhase(m);
    //             return Storage::storage()->addThermo(th);
    //         }
    //         catch (CanteraError) { return -1; }
    //     }

    size_t DLL_EXPORT newThermoFromXML(int mxml)
    {
        try {
            XML_Node& x = XmlCabinet::item(mxml);
            thermo_t* th = newPhase(x);
            return Storage::storage()->addThermo(th);
        } catch (CanteraError) {
            return -1;
        }
    }

    //int DLL_EXPORT th_phase(int n) {
    //    return th(n)->phase().index();
    // }

    size_t DLL_EXPORT th_nSpecies(size_t n)
    {
        return th(n)->nSpecies();
    }

    int DLL_EXPORT th_eosType(int n)
    {
        return th(n)->eosType();
    }

    double DLL_EXPORT th_enthalpy_mole(int n)
    {
        try {
            return th(n)->enthalpy_mole();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_intEnergy_mole(int n)
    {
        try {
            return th(n)->intEnergy_mole();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_entropy_mole(int n)
    {
        try {
            return th(n)->entropy_mole();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_gibbs_mole(int n)
    {
        try {
            return th(n)->gibbs_mole();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_cp_mole(int n)
    {
        try {
            return th(n)->cp_mole();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_cv_mole(int n)
    {
        try {
            return th(n)->cv_mole();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_pressure(int n)
    {
        try {
            return th(n)->pressure();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_enthalpy_mass(int n)
    {
        try {
            return th(n)->enthalpy_mass();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_intEnergy_mass(int n)
    {
        try {
            return th(n)->intEnergy_mass();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_entropy_mass(int n)
    {
        try {
            return th(n)->entropy_mass();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_gibbs_mass(int n)
    {
        try {
            return th(n)->gibbs_mass();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_cp_mass(int n)
    {
        try {
            return th(n)->cp_mass();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_cv_mass(int n)
    {
        try {
            return th(n)->cv_mass();
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_electricPotential(int n)
    {
        try {
            return th(n)->electricPotential();
        } catch (CanteraError) {
            return DERR;
        }
    }

    int DLL_EXPORT th_chemPotentials(int n, size_t lenm, double* murt)
    {
        thermo_t* thrm = th(n);
        size_t nsp = thrm->nSpecies();
        if (lenm >= nsp) {
            thrm->getChemPotentials(murt);
            return 0;
        } else {
            return -10;
        }
    }

    int DLL_EXPORT th_elementPotentials(int n, size_t lenm, double* lambda)
    {
        thermo_t* thrm = th(n);
        size_t nel = thrm->nElements();
        if (lenm >= nel) {
            equilibrate(*thrm, "TP", 0);
            thrm->getElementPotentials(lambda);
            return 0;
        } else {
            return -10;
        }
    }

    int DLL_EXPORT th_setPressure(int n, double p)
    {
        try {
            if (p < 0.0) throw CanteraError("th_setPressure",
                                                "pressure cannot be negative");
            th(n)->setPressure(p);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT th_set_HP(int n, double* vals)
    {
        try {
            if (vals[1] < 0.0)
                throw CanteraError("th_set_HP",
                                   "pressure cannot be negative");
            th(n)->setState_HP(vals[0],vals[1]);
            if (th(n)->temperature() < 0.0)
                throw CanteraError("th_set_HP",
                                   "temperature cannot be negative");
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT th_set_UV(int n, double* vals)
    {
        try {
            if (vals[1] < 0.0)
                throw CanteraError("th_set_UV",
                                   "specific volume cannot be negative");
            th(n)->setState_UV(vals[0],vals[1]);
            if (th(n)->temperature() < 0.0)
                throw CanteraError("th_set_UV",
                                   "temperature cannot be negative");
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT th_set_SV(int n, double* vals)
    {
        try {
            th(n)->setState_SV(vals[0],vals[1]);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT th_set_SP(int n, double* vals)
    {
        try {
            th(n)->setState_SP(vals[0],vals[1]);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT th_equil(int n, char* XY, int solver,
                            double rtol, int maxsteps, int maxiter, int loglevel)
    {
        try {
            equilibrate(*th(n), XY, solver, rtol, maxsteps,
                        maxiter, loglevel);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    doublereal DLL_EXPORT th_refPressure(int n)
    {
        return th(n)->refPressure();
    }

    doublereal DLL_EXPORT th_minTemp(int n, int k)
    {
        return th(n)->minTemp(k);
    }

    doublereal DLL_EXPORT th_maxTemp(int n, int k)
    {
        return th(n)->maxTemp(k);
    }


    int DLL_EXPORT th_getEnthalpies_RT(int n, size_t lenm, double* h_rt)
    {
        try {
            thermo_t* thrm = th(n);
            size_t nsp = thrm->nSpecies();
            if (lenm >= nsp) {
                thrm->getEnthalpy_RT_ref(h_rt);
                return 0;
            } else {
                return -10;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT th_getEntropies_R(int n, size_t lenm, double* s_r)
    {
        try {
            thermo_t* thrm = th(n);
            size_t nsp = thrm->nSpecies();
            if (lenm >= nsp) {
                thrm->getEntropy_R_ref(s_r);
                return 0;
            } else {
                return -10;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT th_getCp_R(int n, size_t lenm, double* cp_r)
    {
        try {
            thermo_t* thrm = th(n);
            size_t nsp = thrm->nSpecies();
            if (lenm >= nsp) {
                thrm->getCp_R_ref(cp_r);
                return 0;
            } else {
                return -10;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT th_setElectricPotential(int n, double v)
    {
        th(n)->setElectricPotential(v);
        return 0;
    }

    //-------------- pure fluids ---------------//
#ifdef WITH_PURE_FLUIDS

    double DLL_EXPORT th_critTemperature(int n)
    {
        return pfprop(n,0);
    }

    double DLL_EXPORT th_critPressure(int n)
    {
        return purefluid(n)->critPressure();
    }

    double DLL_EXPORT th_critDensity(int n)
    {
        return purefluid(n)->critDensity();
    }

    double DLL_EXPORT th_vaporFraction(int n)
    {
        return purefluid(n)->vaporFraction();
    }

    double DLL_EXPORT th_satTemperature(int n, double p)
    {
        try {
            return purefluid(n)->satTemperature(p);
        } catch (CanteraError) {
            return DERR;
        }
    }

    double DLL_EXPORT th_satPressure(int n, double t)
    {
        try {
            return purefluid(n)->satPressure(t);
        } catch (CanteraError) {
            return DERR;
        }
    }

    int DLL_EXPORT th_setState_Psat(int n, double p, double x)
    {
        try {
            purefluid(n)->setState_Psat(p, x);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT th_setState_Tsat(int n, double t, double x)
    {
        try {
            purefluid(n)->setState_Tsat(t, x);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }
#else

    double DLL_EXPORT th_critTemperature(int n)
    {
        return DERR;
    }

    double DLL_EXPORT th_critPressure(int n)
    {
        return DERR;
    }

    double DLL_EXPORT th_critDensity(int n)
    {
        return DERR;
    }

    double DLL_EXPORT th_vaporFraction(int n)
    {
        return DERR;
    }

    double DLL_EXPORT th_satTemperature(int n, double p)
    {
        return DERR;
    }

    double DLL_EXPORT th_satPressure(int n, double t)
    {
        return DERR;
    }

    int DLL_EXPORT th_setState_Psat(int n, double p, double x)
    {
        return DERR;
    }

    int DLL_EXPORT th_setState_Tsat(int n, double t, double x)
    {
        return DERR;
    }
#endif



    //-------------- Kinetics ------------------//

    size_t DLL_EXPORT newKineticsFromXML(int mxml, int iphase,
                                         int neighbor1, int neighbor2, int neighbor3,
                                         int neighbor4)
    {
        try {
            XML_Node& x = XmlCabinet::item(mxml);
            vector<thermo_t*> phases;
            phases.push_back(th(iphase));
            if (neighbor1 >= 0) {
                phases.push_back(th(neighbor1));
                if (neighbor2 >= 0) {
                    phases.push_back(th(neighbor2));
                    if (neighbor3 >= 0) {
                        phases.push_back(th(neighbor3));
                        if (neighbor4 >= 0) {
                            phases.push_back(th(neighbor4));
                        }
                    }
                }
            }
            Kinetics* kin = newKineticsMgr(x, phases);
            if (kin) {
                return Storage::storage()->addKinetics(kin);
            } else {
                return 0;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT installRxnArrays(int pxml, int ikin,
                                    char* default_phase)
    {
        try {
            XML_Node& p = XmlCabinet::item(pxml);
            kinetics_t* k = kin(ikin);
            string defphase = string(default_phase);
            installReactionArrays(p, *k, defphase);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    //-------------------------------------
    int DLL_EXPORT kin_type(int n)
    {
        return kin(n)->type();
    }

    size_t DLL_EXPORT kin_start(int n, int p)
    {
        return kin(n)->kineticsSpeciesIndex(0,p);
    }

    size_t DLL_EXPORT kin_speciesIndex(int n, const char* nm, const char* ph)
    {
        return kin(n)->kineticsSpeciesIndex(string(nm), string(ph));
    }

    //---------------------------------------

    size_t DLL_EXPORT kin_nSpecies(int n)
    {
        return kin(n)->nTotalSpecies();
    }

    size_t DLL_EXPORT kin_nReactions(int n)
    {
        return kin(n)->nReactions();
    }

    size_t DLL_EXPORT kin_nPhases(int n)
    {
        return kin(n)->nPhases();
    }

    size_t DLL_EXPORT kin_phaseIndex(int n, char* ph)
    {
        return kin(n)->phaseIndex(string(ph));
    }

    size_t DLL_EXPORT kin_reactionPhaseIndex(int n)
    {
        return kin(n)->reactionPhaseIndex();
    }

    double DLL_EXPORT kin_reactantStoichCoeff(int n, int k, int i)
    {
        return kin(n)->reactantStoichCoeff(k,i);
    }

    double DLL_EXPORT kin_productStoichCoeff(int n, int k, int i)
    {
        return kin(n)->productStoichCoeff(k,i);
    }

    int DLL_EXPORT kin_reactionType(int n, int i)
    {
        return kin(n)->reactionType(i);
    }

    int DLL_EXPORT kin_getFwdRatesOfProgress(int n, size_t len, double* fwdROP)
    {
        Kinetics* k = kin(n);
        try {
            if (len >= k->nReactions()) {
                k->getFwdRatesOfProgress(fwdROP);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT kin_getRevRatesOfProgress(int n, size_t len, double* revROP)
    {
        Kinetics* k = kin(n);
        try {
            if (len >= k->nReactions()) {
                k->getRevRatesOfProgress(revROP);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT kin_isReversible(int n, int i)
    {
        return (int)kin(n)->isReversible(i);
    }

    int DLL_EXPORT kin_getNetRatesOfProgress(int n, size_t len, double* netROP)
    {
        try {
            Kinetics* k = kin(n);
            if (len >= k->nReactions()) {
                k->getNetRatesOfProgress(netROP);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT kin_getFwdRateConstants(int n, size_t len, double* kfwd)
    {
        try {
            Kinetics* k = kin(n);
            if (len >= k->nReactions()) {
                k->getFwdRateConstants(kfwd);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT kin_getRevRateConstants(int n, int doIrreversible, size_t len, double* krev)
    {
        try {
            Kinetics* k = kin(n);
            bool doirrev = false;
            if (doIrreversible != 0) {
                doirrev = true;
            }
            if (len >= k->nReactions()) {
                k->getRevRateConstants(krev, doirrev);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
    }


    int DLL_EXPORT kin_getActivationEnergies(int n, size_t len, double* E)
    {
        try {
            Kinetics* k = kin(n);
            if (len >= k->nReactions()) {
                k->getActivationEnergies(E);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
    }


    int DLL_EXPORT kin_getDelta(int n, int job, size_t len, double* delta)
    {
        try {
            Kinetics* k = kin(n);
            if (len < k->nReactions()) {
                return ERR;
            }
            switch (job) {
            case 0:
                k->getDeltaEnthalpy(delta);
                break;
            case 1:
                k->getDeltaGibbs(delta);
                break;
            case 2:
                k->getDeltaEntropy(delta);
                break;
            case 3:
                k->getDeltaSSEnthalpy(delta);
                break;
            case 4:
                k->getDeltaSSGibbs(delta);
                break;
            case 5:
                k->getDeltaSSEntropy(delta);
                break;
            default:
                return ERR;
            }
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }


    int DLL_EXPORT kin_getDeltaEntropy(int n, size_t len, double* deltaS)
    {
        try {
            Kinetics* k = kin(n);
            if (len >= k->nReactions()) {
                k->getDeltaEntropy(deltaS);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
    }


    int DLL_EXPORT kin_getCreationRates(int n, size_t len, double* cdot)
    {
        try {
            Kinetics* k = kin(n);
            if (len >= k->nTotalSpecies()) {
                k->getCreationRates(cdot);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT kin_getDestructionRates(int n, size_t len, double* ddot)
    {
        try {
            Kinetics* k = kin(n);
            if (len >= k->nTotalSpecies()) {
                k->getDestructionRates(ddot);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
        //catch (...) {return ERR;}
    }

    int DLL_EXPORT kin_getNetProductionRates(int n, size_t len, double* wdot)
    {
        try {
            Kinetics* k = kin(n);
            if (len >= k->nTotalSpecies()) {
                k->getNetProductionRates(wdot);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT kin_getSourceTerms(int n, size_t len, double* ydot)
    {
        try {
            Kinetics* k = kin(n);
            ThermoPhase* p = &k->thermo();
            const vector_fp& mw = p->molecularWeights();
            size_t nsp = mw.size();
            double rrho = 1.0/p->density();
            if (len >= nsp) {
                k->getNetProductionRates(ydot);
                multiply_each(ydot, ydot + nsp, mw.begin());
                scale(ydot, ydot + nsp, ydot, rrho);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    double DLL_EXPORT kin_multiplier(int n, int i)
    {
        return kin(n)->multiplier(i);
    }

    size_t DLL_EXPORT kin_phase(int n, size_t i)
    {
        return kin(n)->thermo(i).index();
    }

    int DLL_EXPORT kin_getEquilibriumConstants(int n, size_t len, double* kc)
    {
        try {
            Kinetics* k = kin(n);
            if (len >= k->nReactions()) {
                k->getEquilibriumConstants(kc);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT kin_getReactionString(int n, int i, int len, char* buf)
    {
        try {
            Kinetics* k = kin(n);
            string r = k->reactionString(i);
            int lout = min(len, (int)r.size());
            copy(r.c_str(), r.c_str() + lout, buf);
            buf[lout] = '\0';
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT kin_setMultiplier(int n, int i, double v)
    {
        try {
            if (v >= 0.0) {
                kin(n)->setMultiplier(i,v);
                return 0;
            } else {
                return ERR;
            }
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT kin_advanceCoverages(int n, double tstep)
    {
        try {
            Kinetics* k = kin(n);
            if (k->type() == cInterfaceKinetics) {
                ((InterfaceKinetics*)k)->advanceCoverages(tstep);
            } else {
                throw CanteraError("kin_advanceCoverages",
                                   "wrong kinetics manager type");
            }
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    //------------------- Transport ---------------------------

    size_t DLL_EXPORT newTransport(char* model,
                                   int ith, int loglevel)
    {
        string mstr = string(model);
        thermo_t* t = th(ith);
        try {
            Transport* tr = newTransportMgr(mstr,t, loglevel);
            return Storage::storage()->addTransport(tr);
        } catch (CanteraError) {
            return -1;
        }
    }

    double DLL_EXPORT trans_viscosity(int n)
    {
        try {
            return trans(n)->viscosity();
        } catch (CanteraError) {
            return -1.0;
        }
    }

    double DLL_EXPORT trans_thermalConductivity(int n)
    {
        try {
            return trans(n)->thermalConductivity();
        } catch (CanteraError) {
            return -1.0;
        }
    }

    int DLL_EXPORT trans_getThermalDiffCoeffs(int n, int ldt, double* dt)
    {
        try {
            trans(n)->getThermalDiffCoeffs(dt);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT trans_getMixDiffCoeffs(int n, int ld, double* d)
    {
        try {
            trans(n)->getMixDiffCoeffs(d);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT trans_getBinDiffCoeffs(int n, int ld, double* d)
    {
        try {
            trans(n)->getBinaryDiffCoeffs(ld,d);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT trans_getMultiDiffCoeffs(int n, int ld, double* d)
    {
        try {
            trans(n)->getMultiDiffCoeffs(ld,d);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT trans_setParameters(int n, int type, int k, double* d)
    {
        try {
            trans(n)->setParameters(type, k, d);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT trans_getMolarFluxes(int n, const double* state1,
                                        const double* state2, double delta, double* fluxes)
    {
        try {
            trans(n)->getMolarFluxes(state1, state2, delta, fluxes);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT trans_getMassFluxes(int n, const double* state1,
                                       const double* state2, double delta, double* fluxes)
    {
        try {
            trans(n)->getMassFluxes(state1, state2, delta, fluxes);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    //-------------------- Functions ---------------------------

    int DLL_EXPORT import_phase(int nth, int nxml, char* id)
    {
        thermo_t* thrm = th(nth);
        XML_Node& node = XmlCabinet::item(nxml);
        string idstr = string(id);
        try {
            importPhase(node, thrm);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT import_kinetics(int nxml, char* id,
                                   int nphases, integer* ith, int nkin)
    {
        vector<thermo_t*> phases;
        for (int i = 0; i < nphases; i++) {
            phases.push_back(th(ith[i]));
        }
        XML_Node& node = XmlCabinet::item(nxml);
        Kinetics* k = kin(nkin);
        string idstr = string(id);
        try {
            importKinetics(node, phases, k);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }


    int DLL_EXPORT phase_report(int nth,
                                int ibuf, char* buf, int show_thermo)
    {
        try {
            bool stherm = (show_thermo != 0);
            string s = report(*th(nth), stherm);
            if (int(s.size()) > ibuf - 1) {
                return -(static_cast<int>(s.size()) + 1);
            }
            copy(s.begin(), s.end(), buf);
            buf[s.size() - 1] = '\0';
            return 0;

        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT write_phase(int nth, int show_thermo)
    {
        try {
            bool stherm = (show_thermo != 0);
            writephase(*th(nth), stherm);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT write_HTML_log(char* file)
    {
        write_logfile(string(file));
        return 0;
    }

    int DLL_EXPORT getCanteraError(int buflen, char* buf)
    {
        string e;
        e = lastErrorMessage();
        if (buflen > 0) {
            int n = min(static_cast<int>(e.size()), buflen-1);
            copy(e.begin(), e.begin() + n, buf);
            buf[min(n, buflen-1)] = '\0';
        }
        return int(e.size());
    }

    int DLL_EXPORT showCanteraErrors()
    {
        showErrors();
        return 0;
    }

    int DLL_EXPORT addCanteraDirectory(size_t buflen, char* buf)
    {
        addDirectory(string(buf));
        return 0;
    }

    int DLL_EXPORT setLogWriter(void* logger)
    {
        Logger* logwriter = (Logger*)logger;
        setLogger(logwriter);
        return 0;
    }

    int DLL_EXPORT readlog(int n, char* buf)
    {
        string s;
        writelog("function readlog is deprecated!");
        //getlog(s);
        int nlog = static_cast<int>(s.size());
        if (n < 0) {
            return nlog;
        }
        int nn = min(n-1, nlog);
        copy(s.begin(), s.begin() + nn,
             buf);
        buf[min(nlog, n-1)] = '\0';
        //clearlog();
        return 0;

    }
    int DLL_EXPORT clearStorage()
    {
        try {
            Storage::storage()->clear();
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT delThermo(int n)
    {
        try {
            Storage::storage()->deleteThermo(n);
            return 0;
        } catch (CanteraError) {
            return -1;
        }
    }

    int DLL_EXPORT delKinetics(int n)
    {
        Storage::storage()->deleteKinetics(n);
        return 0;
    }

    int DLL_EXPORT delTransport(int n)
    {
        Storage::storage()->deleteTransport(n);
        return 0;
    }

    int DLL_EXPORT buildSolutionFromXML(char* src, int ixml, char* id,
                                        int ith, int ikin)
    {

        XML_Node* root = 0;
        if (ixml > 0) {
            root = &XmlCabinet::item(ixml);
        }

        thermo_t* t = th(ith);
        kinetics_t* k = kin(ikin);

        Kinetics& kin = *k;
        XML_Node* x, *r=0;
        if (root) {
            r = &root->root();
        }
        x = get_XML_Node(string(src), r);
        //x = find_XML(string(src), r, string(id), "", "phase");
        if (!x) {
            return false;
        }
        importPhase(*x, t);
        kin.addPhase(*t);
        kin.init();
        installReactionArrays(*x, kin, x->id());
        t->setState_TP(300.0, OneAtm);
        if (r) {
            if (&x->root() != &r->root()) {
                delete &x->root();
            }
        } else {
            delete &x->root();
        }
        return 0;
    }


    int DLL_EXPORT ck_to_cti(char* in_file, char* db_file,
                             char* tr_file, char* id_tag, int debug, int validate)
    {
        bool dbg = (debug != 0);
        bool val = (validate != 0);
        return pip::convert_ck(in_file, db_file, tr_file, id_tag, dbg, val);
    }


    int DLL_EXPORT writelogfile(char* logfile)
    {
        write_logfile(string(logfile));
        return 0;
    }


}