/**
 * 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.
 */

#include "platform.h"
#include "Exception.h"
#include "ExceptionInternal.h"
#include "Logger.h"
#include "UnorderedMap.h"
#include "client/KerberosName.h"
#include "client/UserInfo.h"
#include "network/Syscall.h"
#include "network/TcpSocket.h"
#include "server/NamenodeProxy.h"

#include <regex>
#include <vector>

int poll(struct pollfd *fds, unsigned long nfds, int timeout) {
    return WSAPoll(fds, nfds, timeout);
}

namespace hdfs {
namespace internal {

/* InputStreamImpl.cc */
unordered_set<std::string> BuildLocalAddrSet() {
#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))
    DWORD dwSize = 0;
    DWORD dwRetVal = 0;
    unsigned int i = 0;

    // Set the flags to pass to GetAdaptersAddresses
    ULONG flags = GAA_FLAG_INCLUDE_PREFIX;

    // default to unspecified address family (both)
    ULONG family = AF_UNSPEC;
    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
    ULONG outBufLen = 0;

    PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
    PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
    PIP_ADAPTER_ANYCAST_ADDRESS pAnycast = NULL;
    PIP_ADAPTER_MULTICAST_ADDRESS pMulticast = NULL;

    outBufLen = sizeof (IP_ADAPTER_ADDRESSES);
    pAddresses = (IP_ADAPTER_ADDRESSES *) MALLOC(outBufLen);

	// Make an initial call to GetAdaptersAddresses to get the
	// size needed into the outBufLen variable
	if (GetAdaptersAddresses(
        family,
        flags,
        NULL,
        pAddresses,
        &outBufLen) == ERROR_BUFFER_OVERFLOW) {
        FREE(pAddresses);
        pAddresses = (IP_ADAPTER_ADDRESSES *) MALLOC(outBufLen);
	}

    if (pAddresses == NULL) {
        THROW(HdfsNetworkException,
            "InputStreamImpl: malloc failed, "
            "cannot get local network interface: %s",
            GetSystemErrorInfo(errno));
    }

    // Make a second call to GetAdapters Addresses to get the
    // actual data we want
    dwRetVal =
        GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);

    if (dwRetVal == NO_ERROR) {
        // If successful, construct the address set
        unordered_set<std::string> set; // to be returned
        std::vector<char> host;
        const char *pHost;
        host.resize(INET6_ADDRSTRLEN + 1);

        pCurrAddresses = pAddresses;
        while (pCurrAddresses) {
            // TODO: scan Anycast, Multicast as well.
            // scan unicast address list
            pUnicast = pCurrAddresses->FirstUnicastAddress;
            while (pUnicast != NULL) {
                memset(&host[0], 0, INET6_ADDRSTRLEN);
                ULONG _family = pUnicast->Address.lpSockaddr->sa_family;
                if (_family == AF_INET) {
                    SOCKADDR_IN *sa_in =
                        (SOCKADDR_IN *)pUnicast->Address.lpSockaddr;
                    pHost = InetNtop(
                        AF_INET,
                        &(sa_in->sin_addr),
                        &host[0],
                        INET6_ADDRSTRLEN);
                }
                else {
                    SOCKADDR_IN6 *sa_in6 =
                        (SOCKADDR_IN6 *)pUnicast->Address.lpSockaddr;
                    pHost = InetNtop(
                        AF_INET,
                        &(sa_in6->sin6_addr),
                        &host[0],
                        INET6_ADDRSTRLEN);
                }
                if (pHost == NULL) {
                    THROW(HdfsNetworkException,
                        "InputStreamImpl: cannot get convert network address to textual form: %s",
                        GetSystemErrorInfo(errno));
                }
                set.insert(pHost);
                pUnicast = pUnicast->Next;
            } // inner while
            pCurrAddresses = pCurrAddresses->Next;
        } // while

        // TODO: replace hardcoded HOST_NAME_MAX
        int _HOST_NAME_MAX = 128;
        host.resize(_HOST_NAME_MAX + 1);
        if (gethostname(&host[0], host.size())) {
            THROW(HdfsNetworkException,
                "InputStreamImpl: cannot get hostname: %s",
                GetSystemErrorInfo(errno));
        }
        set.insert(&host[0]);
        if (pAddresses != NULL) {
            FREE(pAddresses);
        }
        return set;
    }
    else {
        printf("Call to GetAdaptersAddresses failed with error: %d\n",
            dwRetVal);
        if (pAddresses != NULL) {
            FREE(pAddresses);
        }
        THROW(HdfsNetworkException,
            "InputStreamImpl: cannot get local network interface: %s",
            GetSystemErrorInfo(errno));
    }
}

/* TpcSocket.cc */
void TcpSocketImpl::setBlockMode(bool enable) {
    u_long blocking_mode = (enable) ? 0 : 1;
    int rc = syscalls::ioctlsocket(sock, FIONBIO, &blocking_mode);
    if (rc == SOCKET_ERROR) {
        THROW(HdfsNetworkException, "Get socket flag failed for remote node %s: %s",
            remoteAddr.c_str(), GetSystemErrorInfo(errno));
    }
}

/* NamenodeProxy.cc */
static std::string GetTmpPath() {
    char lpTempPathBuffer[MAX_PATH];
    //  Gets the temp path env string (no guarantee it's a valid path).
    DWORD dwRetVal = GetTempPath(
        MAX_PATH, // length of the buffer
        lpTempPathBuffer); // buffer for path
    if (dwRetVal > MAX_PATH || (dwRetVal == 0))
        THROW(HdfsException, "GetTmpPath failed");
    return std::string(lpTempPathBuffer);
}

static uint32_t GetInitNamenodeIndex(const std::string id) {
    std::string path = GetTmpPath();
    path += id;
    HANDLE fd = INVALID_HANDLE_VALUE;
    uint32_t index = 0;

    fd = CreateFile(
        path.c_str(),
        GENERIC_WRITE, // write only
        0, // do not share, is this right shared mode?
        NULL, // default security
        CREATE_NEW, // call fails if file exists, ERROR_FILE_EXISTS
        FILE_ATTRIBUTE_NORMAL, // normal file
        NULL); // no template

    if (fd == INVALID_HANDLE_VALUE) {
        // File already exists, try to open it
        if (GetLastError() == ERROR_FILE_EXISTS) {
            fd = CreateFile(path.c_str(),
                GENERIC_READ, // open for reading
                0, // do not share
                NULL, // default security
                OPEN_EXISTING, // existing file only
                FILE_ATTRIBUTE_NORMAL, // normal file
                NULL // // no template
                );
        }
        else {
            // TODO: log, or throw exception when a file is failed to open
            return 0;
        }
    }
    else {
        DWORD dwBytesToWrite = (DWORD)sizeof(index);
        DWORD dwBytesWritten = 0;
        BOOL bErrorFlag = WriteFile(
            fd,
            &index,
            dwBytesToWrite,
            &dwBytesToWrite,
            NULL);
        // TODO: check error code and number of bytes written
        return index;
    }

    // the file exists, read it
    DWORD dwBytesToRead = 0;
    if (FALSE == ReadFile(fd, &index, sizeof(index), &dwBytesToRead, NULL)) {
        index = 0; // fail to read, don't care
    }
    return index;
}

static void SetInitNamenodeIndex(const std::string & id, uint32_t index) {
    std::string path = GetTmpPath();
    path += id;
    HANDLE fd = INVALID_HANDLE_VALUE;
    fd = CreateFile(
        path.c_str(),
        GENERIC_WRITE, // write only
        0, // do not share, is this right shared mode?
        NULL, // default security
        OPEN_ALWAYS, // call fails if file exists, ERROR_FILE_EXISTS
        FILE_ATTRIBUTE_NORMAL, // normal file
        NULL);                 // no template
    if (fd != INVALID_HANDLE_VALUE) {
        DWORD dwBytesToWrite = (DWORD)sizeof(index);
        DWORD dwBytesWritten = 0;
        BOOL bErrorFlag = WriteFile(
            fd,
            &index,
            dwBytesToWrite,
            &dwBytesToWrite,
            NULL);
    }
}

/* KerberosName.cc */
void KerberosName::parse(const std::string & principal) {
    int rc;
    // primary/instance@REALM
    // [^/@]* = anything but / and @
    static const char * pattern = "([^/@]*)(/([^/@]*))?@([^/@]*)";
    std::tr1::cmatch res;
    std::tr1::regex rx(pattern);
    if (!std::tr1::regex_search(principal.c_str(), res, rx)) {
        // Check if principal is just simply a username without the @thing
        if (principal.find('@') != principal.npos) {
            THROW(HdfsIOException,
                "KerberosName: Malformed Kerberos name: %s",
                principal.c_str());
        }
        else {
            name = principal;
            return;
        }
    }
    if (res[1].length() > 0) {
        name = res[1];
    }
    if (res[3].length() > 0) {
        host = res[3];
    }
    if (res[4].length() > 0) {
        realm = res[4];
    }
}

/* UserInfo.cc */
UserInfo UserInfo::LocalUser() {
    UserInfo retval;
    char username[UNLEN + 1];
    DWORD username_len = UNLEN + 1;
    GetUserName(username, &username_len);
    std::string str(username);

    // Assume for now in Windows real and effective users are the same.
    retval.setRealUser(&str[0]);
    retval.setEffectiveUser(&str[0]);
    return retval;
}

}
}