/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */



#ifndef _HDFS_HTTP_CLIENT_H_
#define _HDFS_HTTP_CLIENT_H_

#include "hdfs.h" /* for tSize */

#include <pthread.h> /* for pthread_t */
#include <unistd.h> /* for size_t */

/** enum indicating the type of hdfs stream */
enum hdfsStreamType
{
    UNINITIALIZED = 0,
    INPUT = 1,
    OUTPUT = 2,
};

/**
 * webhdfsBuffer - used for hold the data for read/write from/to http connection
 */
struct webhdfsBuffer {
    const char *wbuffer;  /* The user's buffer for uploading */
    size_t remaining;     /* Length of content */
    size_t offset;        /* offset for reading */
    /* Check whether the hdfsOpenFile has been called before */
    int openFlag;
    /* Whether to close the http connection for writing */
    int closeFlag;
    /* Synchronization between the curl and hdfsWrite threads */
    pthread_mutex_t writeMutex;
    /* 
     * Transferring thread waits for this condition
     * when there is no more content for transferring in the buffer
     */
    pthread_cond_t newwrite_or_close;
    /* Condition used to indicate finishing transferring (one buffer) */
    pthread_cond_t transfer_finish;
};

/** File handle for webhdfs */
struct webhdfsFileHandle {
    char *absPath;        /* Absolute path of file */
    int bufferSize;       /* Size of buffer */
    short replication;    /* Number of replication */
    tSize blockSize;      /* Block size */
    char *datanode;       /* URL of the DataNode */
    /* webhdfsBuffer handle used to store the upload data */
    struct webhdfsBuffer *uploadBuffer;
    /* The thread used for data transferring */
    pthread_t connThread;
};

/** Type of http header */
enum HttpHeader {
    GET,
    PUT,
    POST,
    DELETE
};

/** Whether to redirect */
enum Redirect {
    YES,
    NO
};

/** Buffer used for holding response */
struct ResponseBuffer {
    char *content;
    size_t remaining;
    size_t offset;
};

/**
 * The response got through webhdfs
 */
struct Response {
    struct ResponseBuffer *body;
    struct ResponseBuffer *header;
};

/**
 * Create and initialize a ResponseBuffer
 *
 * @param buffer Pointer pointing to new created ResponseBuffer handle
 * @return 0 for success, non-zero value to indicate error
 */
int initResponseBuffer(struct ResponseBuffer **buffer) __attribute__ ((warn_unused_result));

/**
 * Free the given ResponseBuffer
 *
 * @param buffer The ResponseBuffer to free
 */
void freeResponseBuffer(struct ResponseBuffer *buffer);

/**
 * Free the given Response
 *
 * @param resp The Response to free
 */
void freeResponse(struct Response *resp);

/**
 * Send the MKDIR request to NameNode using the given URL. 
 * The NameNode will execute the operation and return the result as response.
 *
 * @param url The URL for MKDIR operation
 * @param response Response handle to store response returned from the NameNode
 * @return 0 for success, non-zero value to indicate error
 */
int launchMKDIR(const char *url,
                struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Send the RENAME request to NameNode using the given URL.
 * The NameNode will execute the operation and return the result as response.
 *
 * @param url The URL for RENAME operation
 * @param response Response handle to store response returned from the NameNode
 * @return 0 for success, non-zero value to indicate error
 */
int launchRENAME(const char *url,
                 struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Send the CHMOD request to NameNode using the given URL.
 * The NameNode will execute the operation and return the result as response.
 *
 * @param url The URL for CHMOD operation
 * @param response Response handle to store response returned from the NameNode
 * @return 0 for success, non-zero value to indicate error
 */
int launchCHMOD(const char *url,
                struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Send the GetFileStatus request to NameNode using the given URL.
 * The NameNode will execute the operation and return the result as response.
 *
 * @param url The URL for GetFileStatus operation
 * @param response Response handle to store response returned from the NameNode,
 *                 containing either file status or exception information
 * @return 0 for success, non-zero value to indicate error
 */
int launchGFS(const char *url,
              struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Send the LS (LISTSTATUS) request to NameNode using the given URL.
 * The NameNode will execute the operation and return the result as response.
 *
 * @param url The URL for LISTSTATUS operation
 * @param response Response handle to store response returned from the NameNode
 * @return 0 for success, non-zero value to indicate error
 */
int launchLS(const char *url,
             struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Send the DELETE request to NameNode using the given URL.
 * The NameNode will execute the operation and return the result as response.
 *
 * @param url The URL for DELETE operation
 * @param response Response handle to store response returned from the NameNode
 * @return 0 for success, non-zero value to indicate error
 */
int launchDELETE(const char *url,
                 struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Send the CHOWN request to NameNode using the given URL.
 * The NameNode will execute the operation and return the result as response.
 *
 * @param url The URL for CHOWN operation
 * @param response Response handle to store response returned from the NameNode
 * @return 0 for success, non-zero value to indicate error
 */
int launchCHOWN(const char *url,
                struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Send the OPEN request to NameNode using the given URL, 
 * asking for reading a file (within a range). 
 * The NameNode first redirects the request to the datanode
 * that holds the corresponding first block of the file (within a range),
 * and the datanode returns the content of the file through the HTTP connection.
 *
 * @param url The URL for OPEN operation
 * @param resp The response holding user's buffer. 
               The file content will be written into the buffer.
 * @return 0 for success, non-zero value to indicate error
 */
int launchOPEN(const char *url,
               struct Response* resp) __attribute__ ((warn_unused_result));

/**
 * Send the SETTIMES request to NameNode using the given URL.
 * The NameNode will execute the operation and return the result as response.
 *
 * @param url The URL for SETTIMES operation
 * @param response Response handle to store response returned from the NameNode
 * @return 0 for success, non-zero value to indicate error
 */
int launchUTIMES(const char *url,
                 struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Send the WRITE/CREATE request to NameNode using the given URL.
 * The NameNode will choose the writing target datanodes 
 * and return the first datanode in the pipeline as response
 *
 * @param url The URL for WRITE/CREATE operation connecting to NameNode
 * @param response Response handle to store response returned from the NameNode
 * @return 0 for success, non-zero value to indicate error
 */
int launchNnWRITE(const char *url,
                  struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Send the WRITE request along with to-write content to 
 * the corresponding DataNode using the given URL. 
 * The DataNode will write the data and return the response.
 *
 * @param url The URL for WRITE operation connecting to DataNode
 * @param buffer The webhdfsBuffer containing data to be written to hdfs
 * @param response Response handle to store response returned from the NameNode
 * @return 0 for success, non-zero value to indicate error
 */
int launchDnWRITE(const char *url, struct webhdfsBuffer *buffer,
                  struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Send the WRITE (APPEND) request to NameNode using the given URL. 
 * The NameNode determines the DataNode for appending and 
 * sends its URL back as response.
 *
 * @param url The URL for APPEND operation
 * @param response Response handle to store response returned from the NameNode
 * @return 0 for success, non-zero value to indicate error
 */
int launchNnAPPEND(const char *url, struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Send the SETREPLICATION request to NameNode using the given URL.
 * The NameNode will execute the operation and return the result as response.
 *
 * @param url The URL for SETREPLICATION operation
 * @param response Response handle to store response returned from the NameNode
 * @return 0 for success, non-zero value to indicate error
 */
int launchSETREPLICATION(const char *url,
                         struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Send the APPEND request along with the content to DataNode.
 * The DataNode will do the appending and return the result as response.
 *
 * @param url The URL for APPEND operation connecting to DataNode
 * @param buffer The webhdfsBuffer containing data to be appended
 * @param response Response handle to store response returned from the NameNode
 * @return 0 for success, non-zero value to indicate error
 */
int launchDnAPPEND(const char *url, struct webhdfsBuffer *buffer,
                   struct Response **response) __attribute__ ((warn_unused_result));

/**
 * Thread-safe strerror alternative.
 *
 * @param errnoval  The error code value
 * @return          The error message string mapped to the given error code
 */
const char *hdfs_strerror(int errnoval);

#endif //_HDFS_HTTP_CLIENT_H_
