/*
 * Copyright 2009, Google Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *     * Neither the name of Google Inc. nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


// Helper class to manage the process of uploading metrics.

#include <atlbase.h>
#include <atlcom.h>
#include <atlsafe.h>
#include <time.h>
#include "base/logging.h"

#include "statsreport/uploader.h"
#include "statsreport/aggregator-win32.h"
#include "statsreport/const-win32.h"
#include "statsreport/persistent_iterator-win32.h"
#include "statsreport/formatter.h"
#include "statsreport/common/const_product.h"

namespace stats_report {
// TODO: Refactor to avoid cross platform code duplication.

bool AggregateMetrics() {
  using stats_report::MetricsAggregatorWin32;
  MetricsAggregatorWin32 aggregator(g_global_metrics, PRODUCT_NAME_STRING_WIDE);
  if (!aggregator.AggregateMetrics()) {
    DLOG(WARNING) << "Metrics aggregation failed for reasons unknown";
    return false;
  }

  return true;
}


static bool ReportMetrics(const char* extra_url_data,
                          const char* user_agent,
                          DWORD interval,
                          StatsUploader* stats_uploader) {
  PersistentMetricsIteratorWin32 it(PRODUCT_NAME_STRING_WIDE), end;
  Formatter formatter(CStringA(PRODUCT_NAME_STRING), interval);

  for (; it != end; ++it)
    formatter.AddMetric(*it);
  DLOG(INFO) << "formatter.output() = " << formatter.output();
  return stats_uploader->UploadMetrics(extra_url_data, user_agent,
                                       formatter.output().c_str());
}

void ResetPersistentMetrics(CRegKey *key) {
  key->DeleteValue(kLastTransmissionTimeValueName);
  key->DeleteSubKey(kCountsKeyName);
  key->DeleteSubKey(kTimingsKeyName);
  key->DeleteSubKey(kIntegersKeyName);
  key->DeleteSubKey(kBooleansKeyName);
}

// Returns:
//   true if metrics were uploaded successfully, false otherwise
//   Note: False does not necessarily mean an error, just that no metrics
//         were uploaded
bool AggregateAndReportMetrics(const char* extra_url_arguments,
                               const char* user_agent,
                               bool force_report,
                               bool save_old_metrics) {
  StatsUploader stats_uploader;
  return TestableAggregateAndReportMetrics(extra_url_arguments, user_agent,
                                           force_report, save_old_metrics,
                                           &stats_uploader);
}
// Returns:
//   true if metrics were uploaded successfully, false otherwise
//   Note: False does not necessarily mean an error, just that no metrics
//         were uploaded
bool TestableAggregateAndReportMetrics(const char* extra_url_arguments,
                                       const char* user_agent,
                                       bool force_report,
                                       bool save_old_metrics,
                                       StatsUploader* stats_uploader) {
  CString key_name;
  key_name.Format(kStatsKeyFormatString, PRODUCT_NAME_STRING_WIDE);

  CRegKey key;
  LONG err = key.Create(HKEY_CURRENT_USER, key_name);
  if (ERROR_SUCCESS != err) {
    DLOG(WARNING) << "Unable to open metrics key";
    return false;
  }

  DWORD now = static_cast<DWORD>(time(NULL));

  // Retrieve the last transmission time
  DWORD last_transmission_time;
  DWORD value_type;
  ULONG value_len = sizeof(last_transmission_time);
  err = key.QueryValue(kLastTransmissionTimeValueName, &value_type,
                       &last_transmission_time, &value_len);

  // if last transmission time is missing or at all hinky, then
  // let's wipe all info and start afresh.
  if (ERROR_SUCCESS != err || REG_DWORD != value_type ||
      sizeof(last_transmission_time) != value_len ||
      last_transmission_time > now) {
    DLOG(WARNING) << "Hinky or missing last transmission time, wiping stats";

    if (!save_old_metrics) ResetPersistentMetrics(&key);

    err = key.SetValue(kLastTransmissionTimeValueName, REG_DWORD,
                       &now, sizeof(now));
    if (ERROR_SUCCESS != err) {
      DLOG(ERROR) << "Unable to write last transmission value, error "
                  << std::hex << err;
    }
    // Force a report of the stats so we get everything currently in there.
    force_report = true;

    // we just wiped everything, let's not waste any more time
    // return; <-- skipping this since we still want to aggregate
  }

  if (!AggregateMetrics()) {
    DLOG(INFO) << "AggregateMetrics returned false";
    return false;
  }

  DLOG(INFO) << "Last transimission time: " << last_transmission_time;
  DLOG(INFO) << "Now: " << now;
  DLOG(INFO) << "Now - Last transmission time: "
             << now - last_transmission_time;
  DLOG(INFO) << "Compared to: " << kStatsUploadIntervalSec;

  // Set last_transmission_time such that it will force
  // an upload of the metrics
  if (force_report) {
    last_transmission_time = now - kStatsUploadIntervalSec;
  }
  if (now - last_transmission_time >= kStatsUploadIntervalSec) {
    bool report_result = ReportMetrics(extra_url_arguments, user_agent,
                                       now - last_transmission_time,
                                       stats_uploader);
    if (report_result) {
      DLOG(INFO) << "Stats upload successful, resetting metrics";

      ResetPersistentMetrics(&key);
    } else {
      DLOG(WARNING) << "Stats upload failed";
    }

    // No matter what, wait another upload interval to try again. It's better
    // to report older stats than hammer on the stats server exactly when it's
    // failed.
    err = key.SetValue(kLastTransmissionTimeValueName, REG_DWORD,
                       &now, sizeof(now));
    return report_result;
  }
  return false;
}

// Used primarily for testing. Default functionality.
bool StatsUploader::UploadMetrics(const char* extra_url_data,
                                  const char* user_agent,
                                  const char *content) {
  return stats_report::UploadMetrics(extra_url_data, user_agent, content);
}

}  // namespace stats_report