/*
 * Copyright 2017 Sony Corporation
 */

#include <list>

#include "Poco/NumberParser.h"
#include "Poco/URI.h"
#include "Poco/Net/HTTPResponse.h"

#include "easyhttpcpp/common/CoreLogger.h"
#include "easyhttpcpp/HttpConstants.h"

#include "HttpCacheStrategy.h"
#include "HttpUtil.h"

namespace easyhttpcpp {

static const std::string Tag = "HttpCacheStrategy";
static const long long OneDaySec = 24 * 60 * 60;

HttpCacheStrategy::HttpCacheStrategy(Request::Ptr pRequest, Response::Ptr pCacheResponse, unsigned long long nowAtEpoch)
        : m_nowAtEpoch(nowAtEpoch), m_pRequest(pRequest), m_pNetworkRequest(pRequest), m_pCacheResponse(pCacheResponse)
        , m_responseDateExisted(false), m_lastModifiedExisted(false), m_expiresExisted(false), m_ageSec(-1)
        , m_ageExisted(false)
{
    if (m_pCacheResponse) {
        // preparation frequent used stuff.
        if (m_pCacheResponse->hasHeader(HttpConstants::HeaderNames::Date)) {
            if (HttpUtil::tryParseDate(m_pCacheResponse->getHeaderValue(HttpConstants::HeaderNames::Date, ""),
                    m_responseDate)) {
                m_responseDateExisted = true;
            }
        }
        if (m_pCacheResponse->hasHeader(HttpConstants::HeaderNames::LastModified)) {
            if (HttpUtil::tryParseDate(m_pCacheResponse->getHeaderValue(HttpConstants::HeaderNames::LastModified, ""),
                    m_lastModified)) {
                m_lastModifiedExisted = true;
            }
        }
        if (m_pCacheResponse->hasHeader(HttpConstants::HeaderNames::Expires)) {
            if (HttpUtil::tryParseDate(m_pCacheResponse->getHeaderValue(HttpConstants::HeaderNames::Expires, ""),
                    m_expires)) {
                m_expiresExisted = true;
            }
        }
        if (m_pCacheResponse->hasHeader(HttpConstants::HeaderNames::Age)) {
            m_ageExisted = true;
            Poco::Int64 value;
            if (Poco::NumberParser::tryParse64(m_pCacheResponse->getHeaderValue(HttpConstants::HeaderNames::Age, ""),
                    value)) {
                m_ageSec = value;
            } else {
                m_ageSec = -1;
            }
        }
        resolveCacheResponseAndNetworkRequest();
    } else {
        // check onlyIfCached
        CacheControl::Ptr pCacheControl = m_pRequest->getCacheControl();
        if (pCacheControl && pCacheControl->isOnlyIfCached()) {
            EASYHTTPCPP_LOG_D(Tag, "can not send request when exist network request and only-if-cached");
            m_pNetworkRequest = NULL;
        }
    }
}

HttpCacheStrategy::~HttpCacheStrategy()
{
}

void HttpCacheStrategy::resolveCacheResponseAndNetworkRequest()
{
    m_pNetworkRequest = NULL;

    // Check CachControl
    unsigned long long ageSec = calculateCacheResponseAge();
    unsigned long long freshSec = calculateFreshnessLifetime();

    CacheControl::Ptr pRequestCacheControl = m_pRequest->getCacheControl();
    long long requestMaxAgeSec = -1;
    long long requestMinFreshSec = -1;
    long long requestMaxStaleSec = -1;
    bool isRequestOnlyIfCached = false;
    if (pRequestCacheControl) {
        requestMaxAgeSec = pRequestCacheControl->getMaxAgeSec();
        requestMinFreshSec = pRequestCacheControl->getMinFreshSec();
        requestMaxStaleSec = pRequestCacheControl->getMaxStaleSec();
        isRequestOnlyIfCached = pRequestCacheControl->isOnlyIfCached();
    }
    CacheControl::Ptr pResponseCacheControl = m_pCacheResponse->getCacheControl();
    bool isResponseMustRevalidate = false;
    bool isResponseNoCache = false;
    long long responseMaxAgeSec = -1;
    if (pResponseCacheControl) {
        isResponseMustRevalidate = pResponseCacheControl->isMustRevalidate();
        isResponseNoCache = pResponseCacheControl->isNoCache();
        responseMaxAgeSec = pResponseCacheControl->getMaxAgeSec();
    }

    if (requestMaxAgeSec != -1) {
        freshSec = std::min(freshSec, static_cast<unsigned long long>(requestMaxAgeSec));
    }
    unsigned long long minFreshSec = 0;
    if (requestMinFreshSec != -1) {
        minFreshSec = static_cast<unsigned long long>(requestMinFreshSec);
    }
    unsigned long long maxStaleSec = 0;
    if (!isResponseMustRevalidate && requestMaxStaleSec != -1) {
        maxStaleSec = static_cast<unsigned long long>(requestMaxStaleSec);
    }
    EASYHTTPCPP_LOG_D(Tag,
            "age condition: no-cache=%d ageSec=%llu minFreshSec=%llu freshSec=%llu maxStaleSec=%llu",
            isResponseNoCache, ageSec, minFreshSec, freshSec, maxStaleSec);
    if (!isResponseNoCache && ageSec + minFreshSec < freshSec + maxStaleSec) {
        std::list<std::pair<std::string, std::string> > extraHeaders;
        // RFC 2616 14.9.3 Modifications of the Basic Expiration Mechanism
        // if age is within range of stale, add warning header.
        if (ageSec + minFreshSec >= freshSec) {
            extraHeaders.push_back(std::make_pair(HttpConstants::HeaderNames::Warning,
                    HttpConstants::HeaderValues::ResponseIsStale));
            EASYHTTPCPP_LOG_D(Tag, "add warning header : %s", HttpConstants::HeaderValues::ResponseIsStale);
        }
        // RFC 2616 13.2.4 Expiration Calculations
        // if age is over one day and max-age exist and expires not exist, add warning header.
        if (ageSec > OneDaySec && responseMaxAgeSec == -1 && !m_expiresExisted) {
            extraHeaders.push_back(std::make_pair(HttpConstants::HeaderNames::Warning,
                    HttpConstants::HeaderValues::HeuristicExpiration));
            EASYHTTPCPP_LOG_D(Tag, "add warning header : %s", HttpConstants::HeaderValues::HeuristicExpiration);
        }
        if (extraHeaders.size() > 0) {
            Response::Builder responseBuilder(m_pCacheResponse);
            for (std::list<std::pair<std::string, std::string> >::const_iterator it = extraHeaders.begin();
                    it != extraHeaders.end(); it++) {
                responseBuilder.addHeader(it->first, it->second);
            }
            m_pCacheResponse = responseBuilder.build();
        }
        EASYHTTPCPP_LOG_D(Tag, "resolve to use cache response. ageSec + minFreshSec=%llu freshSec + maxStaleSec=%llu",
                ageSec + minFreshSec, freshSec + maxStaleSec);
        return;
    }

    // check onlyIfCached
    if (isRequestOnlyIfCached) {
        EASYHTTPCPP_LOG_D(Tag, "can not send request when exist network request and only-if-cached");
        m_pCacheResponse = NULL;
        return;
    }

    // check conditional request
    Headers conditionalRequestHeaders;
    if (m_pCacheResponse->hasHeader(HttpConstants::HeaderNames::ETag)) {
        conditionalRequestHeaders.set(HttpConstants::HeaderNames::IfNoneMatch,
                m_pCacheResponse->getHeaderValue(HttpConstants::HeaderNames::ETag, ""));
        EASYHTTPCPP_LOG_D(Tag, "conditional request: If-None-Match: ETag");
    } else if (m_pCacheResponse->hasHeader(HttpConstants::HeaderNames::LastModified)) {
        conditionalRequestHeaders.set(HttpConstants::HeaderNames::IfModifiedSince, m_pCacheResponse->getHeaderValue(
                HttpConstants::HeaderNames::LastModified, ""));
        EASYHTTPCPP_LOG_D(Tag, "conditional request: If-Modified-Since: Last-Modified");
    } else if (m_pCacheResponse->hasHeader(HttpConstants::HeaderNames::Date)) {
        conditionalRequestHeaders.set(HttpConstants::HeaderNames::IfModifiedSince,
                m_pCacheResponse->getHeaderValue(HttpConstants::HeaderNames::Date, ""));
        EASYHTTPCPP_LOG_D(Tag, "conditional request: If-Modified-Since: Date");
    } else {
        EASYHTTPCPP_LOG_D(Tag, "not use cache response because could not make conditional request.");
        m_pCacheResponse = NULL;
    }

    // create network request
    Request::Builder requestBuilder(m_pRequest);
    for (Headers::HeaderMap::ConstIterator it = conditionalRequestHeaders.begin();
            it != conditionalRequestHeaders.end(); ++it) {
        requestBuilder.setHeader(it->first, it->second);
    }
    m_pNetworkRequest = requestBuilder.build();
}

Request::Ptr HttpCacheStrategy::getNetworkRequest()
{
    return m_pNetworkRequest;
}

Response::Ptr HttpCacheStrategy::getCachedResponse()
{
    return m_pCacheResponse;
}

unsigned long long HttpCacheStrategy::calculateCacheResponseAge()
{
    // reference RFC 2616 13.2.3 Age Calculations

    //             |<-- a: -->| a: apparentReceivedAge   
    // |<- responseDuration ->|<--- residentDuration  --->|
    // |-----------|----------|---------------------------|
    // sentRequest |          receiveResponse             now
    //             |
    //             Date header
    // receivedAge = max (apparentReceivedAge, Age header) : age from Date
    //
    // responseDuration : network delay time (from send to response)
    // receivedAge + responseDuration : Age of receive response (include network delay)
    // receivedAge + responseDuration + residentDuration : current Age (include network delay)

    std::time_t receivedResponseSec = m_pCacheResponse->getReceivedResponseSec();
    long long apparentReceivedAge = 0;
    if (m_responseDateExisted) {
        apparentReceivedAge = std::max(0LL, static_cast<long long> (receivedResponseSec - m_responseDate.epochTime()));
    }
    long long receivedAge = apparentReceivedAge;
    if (m_ageExisted) {
        receivedAge = std::max(apparentReceivedAge, m_ageSec);
    }
    long long responseDuration = receivedResponseSec - m_pCacheResponse->getSentRequestSec();
    long long residentDuration = m_nowAtEpoch - receivedResponseSec;

    return static_cast<unsigned long long>(receivedAge + responseDuration + residentDuration);
}

unsigned long long HttpCacheStrategy::calculateFreshnessLifetime()
{
    // RFC 2616 13.2.4 Expiration Calculations
    CacheControl::Ptr pResponseCacheControl = m_pCacheResponse->getCacheControl();
    if (pResponseCacheControl && pResponseCacheControl->getMaxAgeSec() != -1) {
        // MaxAge
        EASYHTTPCPP_LOG_D(Tag, "calculateFreshnessLifetime: use max-age");
        return static_cast<unsigned long long>(pResponseCacheControl->getMaxAgeSec());
    } else if (m_expiresExisted) {
        // Expires - (Date or receivedResponseSec))
        EASYHTTPCPP_LOG_D(Tag, "calculateFreshnessLifetime: use Expires");
        long long responseSec = m_pCacheResponse->getReceivedResponseSec();
        if (m_responseDateExisted) {
            responseSec = m_responseDate.epochTime();
        }
        long long delta = m_expires.epochTime() - responseSec;
        return static_cast<unsigned long long>(delta > 0 ? delta : 0);
    } else {
        // RFC 2616 13.2.4 Expiration Calculations
        // if response has Last-Modified, expiration value is 10% of interval.
        // RFC 2616 13.9 Side Effects of GET and HEAD
        // if with query url, cache must not treat response as fresh unless the server provides
        // an explicit expiration time.
        const std::string& url = m_pCacheResponse->getRequest()->getUrl();
        Poco::URI uri(url);
        if (m_lastModifiedExisted && uri.getQuery().empty()) {
            EASYHTTPCPP_LOG_D(Tag, "calculateFreshnessLifetime: use 10%% of Date and sentRequestSec");
            long long responseSec = m_pCacheResponse->getSentRequestSec();
            if (m_responseDateExisted) {
                responseSec = m_responseDate.epochTime();
            }
            long long delta = responseSec - m_lastModified.epochTime();
            return static_cast<unsigned long long>(delta > 0 ? (delta / 10) : 0);
        }
    }
    return 0;
}

bool HttpCacheStrategy::isAvailableToCache(Request::Ptr pRequest)
{
    if (pRequest->getMethod() != Request::HttpMethodGet) {
        return false;
    }
    if (pRequest->hasHeader(HttpConstants::HeaderNames::Authorization)) {
        return false;
    }
    CacheControl::Ptr pCacheControl = pRequest->getCacheControl();
    if (pCacheControl && pCacheControl->isNoCache()) {
        return false;
    }
    if (pRequest->hasHeader(HttpConstants::HeaderNames::IfModifiedSince)) {
        return false;
    }
    if (pRequest->hasHeader(HttpConstants::HeaderNames::IfNoneMatch)) {
        return false;
    }

    return true;
}

bool HttpCacheStrategy::isValidCacheResponse(Response::Ptr pCacheResponse, Response::Ptr pNetworkResponse)
{
    if (pNetworkResponse->getCode() == Poco::Net::HTTPResponse::HTTP_NOT_MODIFIED) {
        EASYHTTPCPP_LOG_D(Tag, "isValidCacheResponse: valid cache. statusCode is Not Modified.");
        return true;
    }

    if (pCacheResponse->hasHeader(HttpConstants::HeaderNames::LastModified)) {
        std::string cacheLastModifiedStr = pCacheResponse->getHeaderValue(
                HttpConstants::HeaderNames::LastModified, "");
        Poco::Timestamp cacheLastModified;
        if (HttpUtil::tryParseDate(cacheLastModifiedStr, cacheLastModified)) {
            if (pNetworkResponse->hasHeader(HttpConstants::HeaderNames::LastModified)) {
                std::string networkLastModifiedStr = pNetworkResponse->getHeaderValue(
                        HttpConstants::HeaderNames::LastModified, "");
                Poco::Timestamp networkLastModified;
                if (HttpUtil::tryParseDate(networkLastModifiedStr, networkLastModified)) {
                    if (networkLastModified < cacheLastModified) {
                        EASYHTTPCPP_LOG_D(Tag,
                                "isValidCacheResponse: valid cache. cache Last-Modified is newer.");
                        return true;
                    }
                } else {
                    EASYHTTPCPP_LOG_D(Tag,
                            "isValidCacheResponse: Last-Modified in NetworkResponse is not supported format.[%s]",
                            cacheLastModifiedStr.c_str());
                }
            }
        } else {
            EASYHTTPCPP_LOG_D(Tag, "isValidCacheResponse: Last-Modified in CachedResponse is not supported format.[%s]",
                    cacheLastModifiedStr.c_str());
        }
    }
    return false;
}

bool HttpCacheStrategy::isCacheable(Response::Ptr pResponse)
{
    Request::Ptr pRequest = pResponse->getRequest();

    // check method
    if (pRequest->getMethod() != Request::HttpMethodGet) {
        EASYHTTPCPP_LOG_D(Tag, "isCacheable: Not Cached Method. [%s]",
                HttpUtil::httpMethodToString(pRequest->getMethod()).c_str());
        return false;
    }

    // check statusCode
    // this check was the OkHttp to reference.
    int statusCode = pResponse->getCode();
    switch (statusCode) {
            // RFC 7231 section 6.1
            // cacheable.
        case Poco::Net::HTTPResponse::HTTP_OK: // 200
        case Poco::Net::HTTPResponse::HTTP_NONAUTHORITATIVE: // 203
        case Poco::Net::HTTPResponse::HTTP_NO_CONTENT: // 204
        case Poco::Net::HTTPResponse::HTTP_MULTIPLE_CHOICES: // 300
        case Poco::Net::HTTPResponse::HTTP_MOVED_PERMANENTLY: // 301
        case Poco::Net::HTTPResponse::HTTP_NOT_FOUND: // 404
        case Poco::Net::HTTPResponse::HTTP_METHOD_NOT_ALLOWED: // 405
        case Poco::Net::HTTPResponse::HTTP_GONE: // 410
        case Poco::Net::HTTPResponse::HTTP_REQUESTURITOOLONG: // 414
        case Poco::Net::HTTPResponse::HTTP_NOT_IMPLEMENTED: // 501
            break;
        case 308: // 308:Permanent Redirect is not declaration in Poco
        case Poco::Net::HTTPResponse::HTTP_FOUND: // 302
        case Poco::Net::HTTPResponse::HTTP_TEMPORARY_REDIRECT: // 307
        {
            // https://tools.ietf.org/html/rfc7234#section-3
            if (pResponse->hasHeader(HttpConstants::HeaderNames::Expires)) {
                break;
            }
            CacheControl::Ptr pResponseCacheControl = pResponse->getCacheControl();
            if (pResponseCacheControl && (pResponseCacheControl->getMaxAgeSec() != -1 ||
                    pResponseCacheControl->isPublic() ||
                    pResponseCacheControl->isPrivate())) {
                break;
            }
            EASYHTTPCPP_LOG_D(Tag, "isCacheable: Not Cached Status. [%d]", statusCode);
            return false;
        }
        default:
            EASYHTTPCPP_LOG_D(Tag, "isCacheable: Not Cached Status. [%d]", statusCode);
            return false;
    }

    // check request
    CacheControl::Ptr pRequestCacheControl = pRequest->getCacheControl();
    if (pRequestCacheControl && pRequestCacheControl->isNoStore()) {
        EASYHTTPCPP_LOG_D(Tag, "isCacheable: Not Cached. request Cache-Control contains no-store.");
        return false;
    }

    if (pRequest->hasHeader(HttpConstants::HeaderNames::Authorization)) {
        EASYHTTPCPP_LOG_D(Tag, "isCacheable: Not Cached. exist Authorization Header.");
        return false;
    }

    // check response
    CacheControl::Ptr pResponseCacheControl = pResponse->getCacheControl();
    if (pResponseCacheControl && pResponseCacheControl->isNoStore()) {
        EASYHTTPCPP_LOG_D(Tag, "isCacheable: Not Cached. exist response Cache-Control contains no-store.");
        return false;
    }
    if (!pResponse->hasContentLength() || pResponse->getContentLength() == -1) {
        if (Poco::icompare(pResponse->getHeaderValue(HttpConstants::HeaderNames::TransferEncoding, ""),
                HttpConstants::HeaderValues::Chunked) == 0) {
            return true;
        } else {
            EASYHTTPCPP_LOG_D(Tag, "isCacheable: Not Cached. not exist Content-Length.");
            return false;
        }
    }
    return true;
}

Headers::Ptr HttpCacheStrategy::combineCacheAndNetworkHeader(Response::Ptr pCacheResponse,
        Response::Ptr pNetworkResponse)
{
    // RFC 2616, 13.5.3 Combining Headers
    // remove 1xx warning.
    // use Hop-by-hop Headers of cache response
    // use cache response header,if not exist in network response.
    // use End-to-end Headers of network response
    // remove Content-Length
    Headers::Ptr pHeaders = new Headers();
    Headers::Ptr pCacheResponseHeaders = pCacheResponse->getHeaders();
    for (Headers::HeaderMap::ConstIterator it = pCacheResponseHeaders->begin(); it != pCacheResponseHeaders->end();
            it++) {
        if (Poco::icompare(it->first, HttpConstants::HeaderNames::Warning) == 0) {
            if (Poco::icompare(it->second, 1, "1") == 0) {
                // drop 1xx warning
                EASYHTTPCPP_LOG_D(Tag, "combineCacheAndNetworkHeader: drop from cached header . [%s]:[%s]",
                        it->first.c_str(), it->second.c_str());
                continue;
            }
        }
        if (Poco::icompare(it->first, HttpConstants::HeaderNames::ContentLength) == 0) {
            pHeaders->add(it->first, it->second);
            continue;
        }
        if (!isEndToEnd(it->first) || !pNetworkResponse->hasHeader(it->first)) {
            pHeaders->add(it->first, it->second);
        }
    }

    Headers::Ptr pNetworkResponseHeaders = pNetworkResponse->getHeaders();
    for (Headers::HeaderMap::ConstIterator it = pNetworkResponseHeaders->begin(); it != pNetworkResponseHeaders->end();
            it++) {
        if (Poco::icompare(it->first, HttpConstants::HeaderNames::ContentLength) == 0) {
            // ignore Content-Length
            continue;
        }
        if (isEndToEnd(it->first)) {
            pHeaders->add(it->first, it->second);
        }
    }

    return pHeaders;
}

bool HttpCacheStrategy::isInvalidCacheMethod(Response::Ptr pResponse)
{
    if (!pResponse->isSuccessful()) {
        return false;
    }
    switch (pResponse->getRequest()->getMethod()) {
        case Request::HttpMethodPost:
        case Request::HttpMethodPatch:
        case Request::HttpMethodPut:
        case Request::HttpMethodDelete:
            EASYHTTPCPP_LOG_D(Tag, "cache invalidated method [%s]",
                    HttpUtil::httpMethodToString(pResponse->getRequest()->getMethod()).c_str());
            return true;
        default:
            return false;
    }
}

bool HttpCacheStrategy::isEndToEnd(const std::string& name)
{
    // RFC 2616 13.5.1 the following header is Hop-by-hop Headers (except the following is End-to-end Headers)
    return ((Poco::icompare(name, HttpConstants::HeaderNames::Connection) != 0) &&
            (Poco::icompare(name, HttpConstants::HeaderNames::KeepAlive) != 0) &&
            (Poco::icompare(name, HttpConstants::HeaderNames::ProxyAuthenticate) != 0) &&
            (Poco::icompare(name, HttpConstants::HeaderNames::ProxyAuthorization) != 0) &&
            (Poco::icompare(name, HttpConstants::HeaderNames::Te) != 0) &&
            (Poco::icompare(name, HttpConstants::HeaderNames::Trailers) != 0) &&
            (Poco::icompare(name, HttpConstants::HeaderNames::TransferEncoding) != 0) &&
            (Poco::icompare(name, HttpConstants::HeaderNames::Upgrade) != 0));
}

} /* namespace easyhttpcpp */