/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/* 
 * File:   Posmag.hh
 * Author: hacene
 *
 * Created on July 21, 2020, 3:42 PM
 */

#ifndef POSMAG_HH
#define POSMAG_HH
#include "MaglibWarpper.hh"

#include "Parameter.hh"
#include "ParamData.hh"
#include "DataTypeMath.hh"
#include "Operation.hh"
#include <vector>

namespace AMDA {
    namespace Parameters {

        using namespace std;

        template<typename DataType, class TOutputParamData>
        class Posmag : public Operation {
        public:

            /**
             * @brief Constructor.
             * @details Create the ParamData type of the input ParamData.
             */
            Posmag(Process& pProcess, ParamDataSpec<vector<DataType> >&paramInput, int isatex, int magout) :
            Operation(pProcess),
            _paramInput(paramInput),
            _paramOutput(new TOutputParamData()),
            _isatex(isatex),
            _magout(magout) {
                _paramDataOutput = _paramOutput;
            };

            /**
             * @brief Constructor.
             * @details Create the ParamData type of the input ParamData.
             */
            Posmag(Process& pProcess, ParamDataSpec<vector<DataType> >&paramInput) :
            Operation(pProcess),
            _paramInput(paramInput),
            _paramOutput(new TOutputParamData()),
            _isatex(0),
            _magout(2) {
                _paramDataOutput = _paramOutput;
            }

            virtual ~Posmag() {
            }

            /**
             * @overload Operation::write(ParamDataIndexInfo &pParamDataIndexInfo)
             */
            void write(ParamDataIndexInfo &pParamDataIndexInfo) {
                for (unsigned int _index = pParamDataIndexInfo._startIndex;
                        _index < pParamDataIndexInfo._startIndex + pParamDataIndexInfo._nbDataToProcess;
                        ++_index) {

                    vector<DataType> in = _paramInput.get(_index);
                    double crtTime = _paramInput.getTime(_index);
                    time_t timestamp = crtTime;
                    struct tm *tmp;
                    tmp = gmtime(&timestamp);
                    double rrmag = std::sqrt(in[0]*in[0]+in[1]*in[1]+in[2]*in[2]);
                    double thetr = std::acos(in[2]/rrmag);
                    double phir = std::atan2(in[1] , in[0]);
                    
                    
                    /*
                     PAR magout (I) : type de champ magnetique externe

                    PAR isatex (I) : type de satellite

                    PAR year   (I) : annee fractionnaire >= 2005

                    PAR rre    (I) : distance radiale geocentrique (rayons terrestres)
                    PAR thetr  (I) : colatitude geocentrique (radians)
                    PAR phir   (I) : longitude geocentrique (radians)

                    PAR alfag  (I) : ascension droite de Greenwich (radians)
                    PAR alfas  (I) : ascension droite du soleil (radians)
                    PAR deltas (I) : declinaison du soleil (radians)

                    PAR tilt   (I) : angle de tilt (radians)

                    PAR rgsm   (I) : matrice de passage du repere geographique au
                    PAR            : repere solaire magnetique

                    PAR rggsm  (I) : matrice de passage du repere geographique au
                    PAR            : repere solaire magnetospherique
                    PAR rgsmg  (I) : matrice de passage du repere magnetospherique
                    PAR            : au repere geographique

                    PAR rgdip  (I) : matrice (3,3) de passage du repere geographique
                    PAR            : au repere dipolaire

                    PAR rgse   (I) : matrice de passage du repere geographique
                    PAR            : au repere solaire ecliptique

                    PAR tetdip (I) : colatitude geocentrique du dipole (radians)
                     
                    PAR phidip (I) : longitude geocentrique du dipole (radians)
                    PAR xgsm   (O) : coordonnee solaire magnetospherique en x (rayons terrestres)
                    PAR ygsm   (O) : coordonnee solaire magnetospherique en y (rayons terrestres)
                    PAR zgsm   (O) : coordonnee solaire magnetospherique en z (rayons terrestres)

                    PAR xgse   (O) : coordonnee solaire ecliptique en x (rayons terrestres)
                    PAR ygse   (O) : coordonnee solaire ecliptique en y (rayons terrestres)
                    PAR zgse   (O) : coordonnee solaire ecliptique en z (rayons terrestres)

                    PAR tgl    (O) : temps geomagnetique local du satellite
                                   : (heures fractionnaires)
                    PAR flg    (O) : parametre L de Galperin
                    PAR xlamb  (O) : latitude invariante (radians)

                    PAR tglc   (O) : temps geomagnetique local du point conjugue
                                   : (heures fractionnaires)

                    PAR hsl    (O) : hauteur de l'ombre (kilometres)

                    PAR clatgm (O) : latitude geomagnetique  (radians)
                    PAR clongm (O) : longitude geomagnetique (radians)
                    PAR iposmg (O) : tableau (dim=15) des indicateurs de positions

                    PAR ier    (O) : code de retour
                     */

                    double xlamb =0.0;
                    double flg = 0.0;
                    double tgl = 1.0;
                    int ifail=10;
                    
                    maglib::maglibWarpper::getPosmag(1900 + tmp->tm_year, 1 + tmp->tm_mon, tmp->tm_mday, tmp->tm_hour, tmp->tm_min, tmp->tm_sec,
                            rrmag, thetr, phir,
                            _isatex, _magout,           
                            tgl, flg, xlamb,ifail);
                    
                    tgl = (std::abs(999.-tgl) < 0.001) ? nan("") : tgl;
                    flg = (std::abs(999.-flg) < 0.001) ? nan("") : flg;
                    xlamb = xlamb*180/ (2*std::asin(1.0));
                    xlamb = (std::abs(999.-xlamb) < 0.001) ? nan("") : xlamb;
                    
                    // test results shud be as 
                    /**
                    const double PI  =3.141592653589793238463;
                     rrmag = 7.0; thetr=30*PI/180.0; phir=25*PI/180;
                     maglib::maglibWarpper::getPosmag(2017,02,15,11,30,0,
                            rrmag, thetr, phir,
                            _isatex, _magout,           
                            tgl, flg, xlamb,ifail);
                     * expected results 
                     *      tgl     14.08
                             flg     18.76
                             xlamb     76.65
                             tglc     15.24
                    */
                    DataType tgl_res =  tgl;
                    DataType xlamb_res = (DataType) xlamb;
                    DataType flg_res = (DataType) flg;
                    _paramOutput->pushTime(crtTime);
                    pushData(tgl_res, xlamb_res, flg_res);
                }


            }
            virtual void pushData(DataType tgl, DataType xlamb, DataType flg) = 0;

        protected:
            ParamDataSpec<std::vector<DataType> >& _paramInput;
            ParamDataSpec<DataType>* _paramOutput;
            int _isatex;
            int _magout;

        };

        /**
         * Ecriture de temps geomagnetique local du satellite (heure fractionnée)
         */
        template<typename DataType>
        class MLT : public Posmag<DataType, ParamDataSpec < DataType > > {
        public:

            MLT(Process& pProcess, ParamDataSpec<vector<DataType> >& paramInput, int isatex, int magout) :
            Posmag<DataType, ParamDataSpec < DataType > > ::Posmag(pProcess, paramInput, isatex, magout) {
            }

            void pushData(DataType tgl, DataType /*xlamb*/, DataType /*flg*/) {

                Posmag<DataType, ParamDataSpec < DataType > > ::_paramOutput->getDataList().push_back(tgl);
            }
        };

        /**
         * Ecriture de invariant latitude 
         */
        template<typename DataType>
        class InvLat : public Posmag<DataType, ParamDataSpec < DataType > > {
        public:

            InvLat(Process& pProcess, ParamDataSpec<vector<DataType> >& paramInput, int isatex, int magout) :
            Posmag<DataType, ParamDataSpec < DataType > > ::Posmag(pProcess, paramInput, isatex, magout) {
            }

            void pushData(DataType /*tgl*/, DataType xlamb, DataType /*flg*/) {

                Posmag<DataType, ParamDataSpec < DataType > > ::_paramOutput->getDataList().push_back(xlamb);
            }
        };

        /**
         * Ecriture du parametre L
         */
        template<typename DataType>
        class Lparam : public Posmag<DataType, ParamDataSpec < DataType > > {
        public:

            Lparam(Process& pProcess, ParamDataSpec<vector<DataType> >& paramInput, int isatex, int magout) :
            Posmag<DataType, ParamDataSpec < DataType > > ::Posmag(pProcess, paramInput, isatex, magout) {
            }

            void pushData(DataType /*tgl*/, DataType /*xlamb*/, DataType flg) {

                Posmag<DataType, ParamDataSpec < DataType > > ::_paramOutput->getDataList().push_back(flg);
            }
        };

    }

}


#endif /* POSMAG_HH */