#include "FEPSim.h"

/**
 * Constructor. Sets data values for RPC Client and socket server.
 * 
 * @param ATMSHost The IP of ATMS Server
 * @param FEP RPC program number
 * @param FEP RPC program revision number
 * @param Socket Server listen port
 */
FEPSim::FEPSim(char * ATMShost, int FEP_PROG, int FEP_REV, int SOCK_PORT) {
    this->ATMSHost = ATMShost;
    this->FEP_PROG = FEP_PROG;
    this->FEP_REV = FEP_REV;
    this->SOCK_PORT = SOCK_PORT;
    this->FEPLogFileName = "FEPSimLog.txt";    
    // clear log file
    FEPLogFile.open(FEPLogFileName, ios::trunc);
    FEPLogFile.close();
}

/**
 * Destructor: closes the log file if open
 */
FEPSim::~FEPSim() {
    FEPLogFile.close();
}

/**
 * Handler for the ATMS RPC Response (to the client RPC Call)
 * @param response pointer to fep_reply struct
 */
void FEPSim::handleCallResponse(void *response) {
    // Failed RPC Call 
    if (response == NULL) { 
        clnt_perror(clnt, "RPC call failed");
    }
    // Successful RPC Call
    else { 
        FEPLogFile << "Successful RPC call to ATMS..." << endl;
    }
}

/**
 * Sends an fep_reply for each station on the FEPLine. 
 * Gets highway status from recieved socket msg.
 * 
 * @param buffer The recieved highway status msg.
 */
void FEPSim::sendReplys(char * buffer) {
    HighwaysParser highwaysParser = HighwaysParser(buffer);
    vector<FEP_LINE*> lines = highwaysParser.lines;
    vector<STATION*> ldsMap = highwaysParser.stations;

    cout << "Starting sendReplys for " << lines.size() << " lines." << endl;
    // Send one reply for every FEPLine
    for (int i = 0; i < lines.size(); i++) {
        fep_reply fepReply;
        FEP_LINE * currLine = lines.at(i);
        // populate reply
        fepReply.reply = SHORTPOLL;
        fepReply.schedule = currLine->schedule;
        fepReply.lineinfo = currLine->lineInfo;
        fepReply.kind = (enum polltype) 0;
        fepReply.flag = (enum replykind) 0;

        fepReply.schedule_sequence = currLine->schedleSeq;
        fepReply.global_sequence = currLine->globalSeq;

        // using current unix time, may need to look at later
        fepReply.schedule_time = time(NULL);

        fepReply.user_info1 = currLine->lineNum;
        fepReply.user_info2 = currLine->lineNum;
        fepReply.system_key = currLine->systemKey;

        fepReply.answers.size = 1;
        fepReply.answers.fep_answer_list_u.shortp.count = 1;
	
        // construct a shortanswer for each station in line
        for (int j = 0; j < currLine->lds.size(); j++) {
            fep_shortanswer fsa;
            STATION * currStation = ldsMap.at(currLine->ldsIndex.at(j));

            // msg: oa, od, currStation.dataPack, od, ff
            fsa.msg.message_len = currStation->length + 2;
            fsa.msg.message[0] = 0x0d;
            fsa.msg.message[1] = 0x0a;
            for (int k = 0; k < currStation->length; k++) {
		//printf("Adding: %d %02X\n", k, currStation->dataPack[k]);	
                fsa.msg.message[2 + k] = currStation->dataPack[k];
            }
            int aa = currStation->length;
            fsa.msg.message[2 + aa] = 0x0d;
            fsa.msg.message[3 + aa] = 0xff;
            
            /*for(int l = 0; l < fsa.msg.message_len + 2; l++)
            {
                printf("%02X", (unsigned char) fsa.msg.message[l]);
            }
            printf("\n");*/
            
            // info
            fsa.info.poll_error_count = 0;
            fsa.info.poll_time = time(NULL);
            fsa.info.poll_user_info1 = currStation->drop; // drop number
            fsa.info.poll_user_info2 = 1; //always 1
            fsa.info.retries = 0;
            fsa.info.status = (enum replystatus) 1;

            fepReply.answers.fep_answer_list_u.shortp.answers[0] = fsa;
            // send out data
            
            FEPLogFile << "Sending fepReply for line #" << currLine->lineNum 
                    << " station number #" 
                    << ldsMap.at(currLine->ldsIndex.at(j)) << endl;
            
            // Transfer the station data to ATMS and listen for response
            handleCallResponse(fep_reply_xfer_32(&fepReply, clnt));
        }
        // pause to let ATMS server catch up
        //unsigned int sleepseconds = 220000;
        //usleep(sleepseconds);
    }
    cout << "Finished." << endl;
}

/**
 * Creates an RPC Client, and on successful creation, sends fep_replys to ATMS.
 * @param The recieved highway status msg.
 */
void FEPSim::manageClientConnection(char * buffer) 
{
    // Attempt to create RPC client
    if (createClient()) 
    {
        // Prepare and send the highway status as FEP replies
        sendReplys(buffer);
        FEPLogFile << "Destroying client..." << endl;
        clnt_destroy(clnt);
        int startTime = time(NULL);
        FEPLogFile << "time is: " << startTime << endl;
    }
}

/**
  * Creates an RPC Client to the ATMS Server. If unsuccessful, returns false
  * @return bool success
  */
bool FEPSim::createClient() {
    /* Create RPC Client to communicate with ATMS */
    bool success = true;

    clnt = clnt_create(this->ATMSHost, FEP_PROG, FEP_REV, "tcp");
    /* Check if client creation failed */
    if (clnt == (CLIENT *) NULL) {
        cerr << "Can't create client to " << this->ATMSHost << endl;
        cerr << "Verify you are connected to ATL network." << endl;
        success = false;
    } else {
        FEPLogFile << "Client created" << endl;
    }
    return success;
}

/**
 * Creates a socket server and awaits the highway status message from the
 * ATMS Driver. Upon receipt of the highway status message, creates an RPC
 * client and sends the fep_replys to the ATMS.
 */
void FEPSim::runSockServer() {
    int sockfd, newsockfd, portno, clilen;
    char buffer[BUFF_SIZE];
    struct sockaddr_in serv_addr, cli_addr;
    int n;
    portno = this->SOCK_PORT;

    /* First call to socket() function */
    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    if (sockfd < 0) {
        perror("ERROR opening socket");
        exit(1);
    }

    /* Initialize socket structure */
    bzero((char *) &serv_addr, sizeof (serv_addr));

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = INADDR_ANY;
    serv_addr.sin_port = htons(portno);

    /* Now bind the host address using bind() call.*/
    if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof (serv_addr)) < 0) {
        perror("ERROR on binding");
        exit(1);
    }

    /* Now start listening for the clients, here process will
     * go in sleep mode and will wait for the incoming connection
     */

    listen(sockfd, 5);
    clilen = sizeof (cli_addr);

    /* Accept actual connections from the client */
    while (1) {
        newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, (socklen_t *) & clilen);

        if (newsockfd < 0) {
            perror("ERROR on accept");
            exit(1);
        }

        /* If connection is established then start communicating */
        // zero out buffer
        bzero(buffer, BUFF_SIZE);
        
        // read XML from socket
        int totBytes = 0;
        while ((n = recv(newsockfd, &buffer[totBytes], sizeof (buffer), 0)) > 0) {
            totBytes += n;
        }

        if (n < 0) {
            perror("ERROR reading from socket");
            exit(1);
        }
        // open log file
        FEPLogFile.open(FEPLogFileName, ios::app);
        // send data to atms
        manageClientConnection(buffer);
        // close log file
        FEPLogFile.close();
        close(newsockfd);
    }
}