#include "SimCore/Position.hpp"
#include "SimCore/data.hpp"
#include <Orders/Order.hpp>
#include <WHISPER/Messages/Message.hpp>
#include <Orders/MoveOrder.hpp>
#include <Orders/protos/MoveOrder.pb.h>
#include <Orders/protos/Order.pb.h>
#include <memory>

namespace Orders 
{

    MoveOrder::MoveOrder(const SimCore::Identifier OwnID, WHISPER::SourceType srcType):
    Order(OwnID,srcType,Orders::MOVE_ORDER)
    {
        Speed = SimCore::Data<double>();
        Course = SimCore::Data<double>();
        StartTime = SimCore::Data<uint64_t>();
        pos_ = SimCore::Position();

    }

    MoveOrder::MoveOrder(const SimCore::Identifier OwnID,WHISPER::SourceType srcType,SimCore::Position pos,double speed,double course , int startTime ):
    Order(OwnID, srcType,Orders::MOVE_ORDER)
    {
        Speed = SimCore::Data<double>();
        Course = SimCore::Data<double>();
        StartTime = SimCore::Data<uint64_t>();
        pos_ = SimCore::Position();


    }
    MoveOrder::~MoveOrder()
    {
    
    }

    
    void MoveOrder::setPosition(SimCore::Position pos)
    {
        pos_ = pos;
    }

    

    SimCore::Position MoveOrder::getPosition(){return pos_;}
    



    WHISPER::Message MoveOrder::buildMessage()
    {   
        WHISPER::Message msg = WHISPER::Message(getOwnID().getUUID(), WHISPER::MsgTopics::COMMANDS  , WHISPER::MsgType::COMMAND , srcType);

        messages::entity::order::MoveOrder MoveOrder = messages::entity::order::MoveOrder();

        if (pos_.isValid()) 
        {
            MoveOrder.mutable_geocentricposition()->set_x(pos_.getGeocentricPos().x());
            MoveOrder.mutable_geocentricposition()->set_y(pos_.getGeocentricPos().y());
            MoveOrder.mutable_geocentricposition()->set_z(pos_.getGeocentricPos().z());
        }

        if (Speed.getValidity() == true) {
            MoveOrder.set_speed(Speed.getValue());
        }
        if (Course.getValidity() == true) {
            MoveOrder.set_course(Course.getValue());
        }

        if (StartTime.getValidity() == true) {
            MoveOrder.mutable_startingtime()->set_seconds(StartTime.getValue());
        }


        return msg;
    }


    std::unique_ptr<MoveOrder> MoveOrder::unpack(WHISPER::Message msg)
     {
        
        if(msg.msgType_ == WHISPER::MsgType::COMMAND)
        {
          auto protoMsg =   msg.getProtoMessage();
          if (protoMsg.has_payload() && protoMsg.payload().Is<messages::entity::order::Order>())
          {
            auto order = messages::entity::order::Order();
            protoMsg.payload().UnpackTo(&order);

            if (order.has_orderpayload() && order.orderpayload().Is<messages::entity::order::MoveOrder>())
            {
                auto moveOrder = messages::entity::order::MoveOrder();
                order.orderpayload().UnpackTo(&moveOrder);
               
                SimCore::Identifier OrderID(order.orderid());
                
                auto MoveOrderObj = std::make_unique<MoveOrder>(OrderID,(WHISPER::SourceType)msg.sourceType_);


                if (moveOrder.has_geocentricposition()) MoveOrderObj->setPosition(SimCore::Position(moveOrder.geocentricposition().x(),moveOrder.geocentricposition().y(),moveOrder.geocentricposition().z()));

                if (moveOrder.has_speed()) MoveOrderObj->Speed.setValue(moveOrder.speed());
                if (moveOrder.has_course()) MoveOrderObj->Course.setValue(moveOrder.course());
                if (moveOrder.has_startingtime()) MoveOrderObj->Course.setValue(moveOrder.mutable_startingtime()->seconds());

               

                return std::move(MoveOrderObj);

            }
          }

        } 
        return nullptr;
     }

    std::unique_ptr<MoveOrder> MoveOrder::unpack(std::string msg)
    {
        if (std::empty(msg) == false &&  msg != "NULL") 
      {
         WHISPER::Message whisperMessage(msg);
         return std::move(unpack(whisperMessage));
      }

      return nullptr;
    }


}