// Copyright 2008-2010 Google Inc.
//
// Licensed 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 "omaha/worker/job_creator.h"

#include <windows.h>
#include <atlcom.h>
#include <cstring>
#include <map>
#include "omaha/common/debug.h"
#include "omaha/common/error.h"
#include "omaha/common/file.h"
#include "omaha/common/logging.h"
#include "omaha/common/path.h"
#include "omaha/common/time.h"
#include "omaha/goopdate/config_manager.h"
#include "omaha/goopdate/const_goopdate.h"
#include "omaha/goopdate/goopdate_xml_parser.h"
#include "omaha/goopdate/request.h"
#include "omaha/goopdate/resource.h"
#include "omaha/goopdate/update_response_data.h"
#include "omaha/worker/application_data.h"
#include "omaha/worker/ping.h"
#include "omaha/worker/worker_event_logger.h"
#include "omaha/worker/worker_metrics.h"

namespace omaha {

HRESULT JobCreator::CreateJobsFromResponses(
    const UpdateResponses& responses,
    const ProductDataVector& products,
    Jobs* jobs,
    Request* ping_request,
    CString* event_log_text,
    CompletionInfo* completion_info) {
  ASSERT1(jobs);
  ASSERT1(ping_request);
  ASSERT1(event_log_text);
  ASSERT1(completion_info);
  CORE_LOG(L2, (_T("[JobCreator::CreateJobsFromResponses]")));

  // First check to see if GoogleUpdate update is available, if so we only
  // create the job for googleupdate and don't create jobs for the rest.
  if (IsGoopdateUpdateAvailable(responses)) {
    return CreateGoopdateJob(responses,
                             products,
                             jobs,
                             ping_request,
                             event_log_text,
                             completion_info);
  }

  return CreateJobsFromResponsesInternal(responses,
                                         products,
                                         jobs,
                                         ping_request,
                                         event_log_text,
                                         completion_info);
}

bool JobCreator::IsGoopdateUpdateAvailable(const UpdateResponses& responses) {
  UpdateResponses::const_iterator iter = responses.find(kGoopdateGuid);
  if (iter == responses.end()) {
    return false;
  }

  const UpdateResponse& update_response = iter->second;
  return (_tcsicmp(kResponseStatusOkValue,
                   update_response.update_response_data().status()) == 0);
}

void JobCreator::AddAppUpdateDeferredPing(const AppData& product_data,
                                          Request* ping_request) {
  ASSERT1(ping_request);

  AppRequest ping_app_request;
  AppRequestData ping_app_request_data(product_data);
  PingEvent ping_event(PingEvent::EVENT_UPDATE_COMPLETE,
                       PingEvent::EVENT_RESULT_UPDATE_DEFERRED,
                       0,
                       0,  // extra code 1
                       product_data.previous_version());
  ping_app_request_data.AddPingEvent(ping_event);
  ping_app_request.set_request_data(ping_app_request_data);
  ping_request->AddAppRequest(ping_app_request);
}

HRESULT JobCreator::CreateGoopdateJob(const UpdateResponses& responses,
                                      const ProductDataVector& products,
                                      Jobs* jobs,
                                      Request* ping_request,
                                      CString* event_log_text,
                                      CompletionInfo* completion_info) {
  ASSERT1(jobs);
  ASSERT1(ping_request);
  ASSERT1(event_log_text);
  ASSERT1(completion_info);

  UpdateResponses::const_iterator it = responses.find(kGoopdateGuid);
  if (it == responses.end()) {
    return E_INVALIDARG;
  }

  UpdateResponses goopdate_responses;
  goopdate_responses[kGoopdateGuid] = it->second;

  // Create a job for GoogleUpdate only and defer updates for other products,
  // if updates are available.
  ProductDataVector goopdate_products;
  bool is_other_app_update_available(false);
  for (size_t i = 0; i < products.size(); ++i) {
    const GUID app_id = products[i].app_data().app_guid();
    if (::IsEqualGUID(app_id, kGoopdateGuid)) {
      goopdate_products.push_back(products[i]);
    } else {
      it = responses.find(app_id);
      if (it != responses.end() && IsUpdateAvailable(it->second)) {
        is_other_app_update_available = true;
        AddAppUpdateDeferredPing(products[i].app_data(), ping_request);
      }
    }
  }
  ASSERT1(goopdate_products.size() == 1);

  if (is_other_app_update_available) {
    ++metric_worker_skipped_app_update_for_self_update;
  }

  return CreateJobsFromResponsesInternal(goopdate_responses,
                                         goopdate_products,
                                         jobs,
                                         ping_request,
                                         event_log_text,
                                         completion_info);
}

HRESULT JobCreator::ReadOfflineManifest(const CString& offline_dir,
                                        const CString& app_guid,
                                        UpdateResponse* response) {
  ASSERT1(response);

  CString manifest_filename = app_guid + _T(".gup");
  CString manifest_path = ConcatenatePath(offline_dir, manifest_filename);
  if (!File::Exists(manifest_path)) {
    return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
  }

  UpdateResponses responses;
  HRESULT hr = GoopdateXmlParser::ParseManifestFile(manifest_path, &responses);
  if (FAILED(hr)) {
    OPT_LOG(LE, (_T("[Could not parse manifest][%s]"), manifest_path));
    return hr;
  }
  ASSERT1(!responses.empty());
  ASSERT1(1 == responses.size());

  UpdateResponses::const_iterator iter = responses.begin();
  *response = iter->second;
  ASSERT1(!app_guid.CompareNoCase(GuidToString(
      response->update_response_data().guid())));
  return S_OK;
}

HRESULT JobCreator::FindOfflineFilePath(const CString& offline_dir,
                                        const CString& app_guid,
                                        CString* file_path) {
  ASSERT1(file_path);
  file_path->Empty();

  CString offline_app_dir = ConcatenatePath(offline_dir, app_guid);
  CString pattern(_T("*"));
  std::vector<CString> files;
  HRESULT hr = FindFiles(offline_app_dir, pattern, &files);
  if (FAILED(hr)) {
    return hr;
  }

  CString local_file_path;
  // Skip over "." and "..".
  size_t i = 0;
  for (; i < files.size(); ++i) {
    local_file_path = ConcatenatePath(offline_app_dir, files[i]);
    if (!File::IsDirectory(local_file_path)) {
      break;
    }
  }
  if (i == files.size()) {
    return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
  }

  *file_path = local_file_path;
  return S_OK;
}

HRESULT JobCreator::CreateOfflineJobs(const CString& offline_dir,
                                      const ProductDataVector& products,
                                      Jobs* jobs,
                                      Request* ping_request,
                                      CString* event_log_text,
                                      CompletionInfo* completion_info) {
  CORE_LOG(L2, (_T("[JobCreator::CreateOfflineJobs]")));
  ASSERT1(jobs);
  ASSERT1(ping_request);
  ASSERT1(event_log_text);
  ASSERT1(completion_info);

  ProductDataVector::const_iterator products_it = products.begin();
  for (; products_it != products.end(); ++products_it) {
    const ProductData& product_data = *products_it;
    CString guid(GuidToString(product_data.app_data().app_guid()));
    UpdateResponse response;
    CString file_path;

    HRESULT hr = ReadOfflineManifest(offline_dir, guid, &response);
    if (SUCCEEDED(hr)) {
      hr = FindOfflineFilePath(offline_dir, guid, &file_path);
    }
    if (SUCCEEDED(hr)) {
      hr = goopdate_utils::ValidateDownloadedFile(
               file_path,
               response.update_response_data().hash(),
               static_cast<uint32>(response.update_response_data().size()));
    }
    if (FAILED(hr)) {
      *completion_info = CompletionInfo(COMPLETION_ERROR, hr, _T(""));
      return hr;
    }

    Job* product_job = NULL;
    hr = HandleProductUpdateIsAvailable(product_data,
                                        response,
                                        &product_job,
                                        ping_request,
                                        event_log_text,
                                        completion_info);
    if (FAILED(hr)) {
      return hr;
    }

    product_job->set_download_file_name(file_path);
    product_job->set_is_offline(true);
    jobs->push_back(product_job);
  }

  return S_OK;
}

HRESULT JobCreator::CreateJobsFromResponsesInternal(
    const UpdateResponses& responses,
    const ProductDataVector& products,
    Jobs* jobs,
    Request* ping_request,
    CString* event_log_text,
    CompletionInfo* completion_info) {
  ASSERT1(jobs);
  ASSERT1(ping_request);
  ASSERT1(event_log_text);
  ASSERT1(completion_info);
  CORE_LOG(L2, (_T("[JobCreator::CreateJobsFromResponsesInternal]")));

  // The ordering needs to be done based on the products array, instead of
  // basing this on the responses. This is because the first element in the
  // job that is created is considered the primary app.
  ProductDataVector::const_iterator products_it = products.begin();
  for (; products_it != products.end(); ++products_it) {
    const ProductData& product_data = *products_it;
    AppData product_app_data = product_data.app_data();

    UpdateResponses::const_iterator iter =
        responses.find(product_app_data.app_guid());
    if (iter == responses.end()) {
      AppRequestData ping_app_request_data(product_app_data);
      HandleResponseNotFound(product_app_data,
                             &ping_app_request_data,
                             event_log_text);
      continue;
    }

    const UpdateResponse& response = iter->second;

    AppManager app_manager(is_machine_);
    // If this is an update job, need to call
    // AppManager::UpdateApplicationState() to make sure the registry is
    // initialized properly.
    if (is_update_) {
      app_manager.UpdateApplicationState(&product_app_data);
    }

    // Write the TT Token, if any, with what the server returned. The server
    // may ask us to clear the token as well.
    app_manager.WriteTTToken(product_app_data, response.update_response_data());

    if (IsUpdateAvailable(response)) {
      if (product_data.app_data().is_update_disabled()) {
        ASSERT1(is_update_);
        ASSERT1(!fail_if_update_not_available_);
        CORE_LOG(L1, (_T("[Update available for update-disabled app][%s]"),
                      GuidToString(product_data.app_data().app_guid())));
        app_manager.ClearUpdateAvailableStats(
            GUID_NULL,
            product_data.app_data().app_guid());
      } else {
        ProductData modified_product_data(product_data);
        modified_product_data.set_app_data(product_app_data);
        Job* product_job = NULL;
        HRESULT hr = HandleProductUpdateIsAvailable(modified_product_data,
                                                    response,
                                                    &product_job,
                                                    ping_request,
                                                    event_log_text,
                                                    completion_info);
        if (FAILED(hr)) {
          return hr;
        }

        jobs->push_back(product_job);
      }
    } else {
      AppRequest ping_app_request;
      AppRequestData ping_app_request_data(product_app_data);
      HRESULT hr = HandleUpdateNotAvailable(product_app_data,
                                            response.update_response_data(),
                                            &ping_app_request_data,
                                            event_log_text,
                                            completion_info);
      // TODO(omaha): It's unclear why the ping is added before the FAILED
      // check here but after it in HandleProductUpdateIsAvailable(). Is this
      // intentional?
      ping_app_request.set_request_data(ping_app_request_data);
      ping_request->AddAppRequest(ping_app_request);
      if (FAILED(hr)) {
        return hr;
      }
    }
  }

  return S_OK;
}

HRESULT JobCreator::HandleProductUpdateIsAvailable(
    const ProductData& product_data,
    const UpdateResponse& response,
    Job** product_job,
    Request* ping_request,
    CString* event_log_text,
    CompletionInfo* completion_info) {
  ASSERT1(product_job);

  AppData product_app_data = product_data.app_data();
  AppRequest ping_app_request;
  AppRequestData ping_app_request_data(product_app_data);

  if (is_update_) {
    // previous_version should have been populated above.
    ASSERT1(!product_app_data.previous_version().IsEmpty());
  } else {
    // Copy the current version of app, if available, to previous version
    // in the AppData object so it is sent in pings.
    AppData existing_app_data;
    AppManager app_manager(is_machine_);
    HRESULT hr = app_manager.ReadAppDataFromStore(
                     GUID_NULL,
                     product_app_data.app_guid(),
                     &existing_app_data);
    if (SUCCEEDED(hr)) {
      product_app_data.set_previous_version(existing_app_data.version());
    }
  }

  ASSERT1(::IsEqualGUID(GUID_NULL, product_app_data.parent_app_guid()));
  HandleUpdateIsAvailable(product_app_data,
                          response.update_response_data(),
                          &ping_app_request_data,
                          event_log_text,
                          product_job);
  ASSERT1(*product_job);
  ping_app_request.set_request_data(ping_app_request_data);

  ping_request->AddAppRequest(ping_app_request);
  return S_OK;
}

void JobCreator::HandleResponseNotFound(const AppData& app_data,
                                        AppRequestData* ping_app_request_data,
                                        CString* event_log_text) {
  ASSERT1(event_log_text);
  ASSERT1(ping_app_request_data);

  PingEvent::Types event_type = is_update_ ?
                                PingEvent::EVENT_UPDATE_COMPLETE :
                                PingEvent::EVENT_INSTALL_COMPLETE;
  PingEvent ping_event(event_type,
                       PingEvent::EVENT_RESULT_ERROR,
                       GOOPDATE_E_NO_SERVER_RESPONSE,
                       0,  // extra code 1
                       app_data.previous_version());
  ping_app_request_data->AddPingEvent(ping_event);

  event_log_text->AppendFormat(
      _T("App=%s, Ver=%s, Status=no-response-received\n"),
      GuidToString(app_data.app_guid()),
      app_data.version());
}

void JobCreator::HandleUpdateIsAvailable(
    const AppData& app_data,
    const UpdateResponseData& response_data,
    AppRequestData* ping_app_request_data,
    CString* event_log_text,
    Job** job) {
  ASSERT1(ping_app_request_data);
  ASSERT1(event_log_text);
  ASSERT1(job);
  ASSERT1(!app_data.is_update_disabled());

  if (is_auto_update_) {
    if (::IsEqualGUID(kGoopdateGuid, app_data.app_guid())) {
      ++metric_worker_self_updates_available;
    } else {
      ++metric_worker_app_updates_available;
    }

    // Only record an update available event for updates.
    // We have other mechanisms, including IID, to track install success.
    AppManager app_manager(is_machine_);
    app_manager.UpdateUpdateAvailableStats(app_data.parent_app_guid(),
                                           app_data.app_guid());
  }

  // Ping and record events only for "real" jobs. On demand update checks only
  // jobs should not ping, since no update is actually applied.
  if (!is_update_check_only_) {
    PingEvent::Types event_type = is_update_ ?
                                  PingEvent::EVENT_UPDATE_APPLICATION_BEGIN :
                                  PingEvent::EVENT_INSTALL_APPLICATION_BEGIN;
    PingEvent ping_event(event_type,
                         PingEvent::EVENT_RESULT_SUCCESS,
                         0,  // error code
                         0,  // extra code 1
                         app_data.previous_version());
    ping_app_request_data->AddPingEvent(ping_event);
  }
  const TCHAR* status = is_update_check_only_ ? _T("check only") :
                        is_update_ ? _T("update") : _T("install");
  event_log_text->AppendFormat(_T("App=%s, Ver=%s, Status=%s\n"),
                               GuidToString(app_data.app_guid()),
                               app_data.version(),
                               status);

  // TODO(omaha): When components are implemented, how do we handle the case
  // that this is just a place holder and does not really need an update?
  // We may be in an app that only needs an update here because it's child
  // components need updates so we'll need to flag the job of that somehow.
  // Unless it's already tagged in the response_data (which does know that
  // there's nothing to download) but the job state will need to be updated.
  scoped_ptr<Job> new_job(new Job(is_update_, ping_));
  new_job->set_app_data(app_data);
  new_job->set_update_response_data(response_data);
  new_job->set_is_background(is_auto_update_);
  new_job->set_is_update_check_only(is_update_check_only_);

  *job = new_job.release();
}

HRESULT JobCreator::HandleUpdateNotAvailable(
    const AppData& app_data,
    const UpdateResponseData& response_data,
    AppRequestData* ping_app_request_data,
    CString* event_log_text,
    CompletionInfo* completion_info) {
  ASSERT1(ping_app_request_data);
  ASSERT1(event_log_text);
  ASSERT1(completion_info);

  PingEvent::Results result_type = PingEvent::EVENT_RESULT_ERROR;
  CompletionInfo info = UpdateResponseDataToCompletionInfo(
      response_data,
      ping_app_request_data->app_data().display_name());
  switch (info.error_code) {
    case static_cast<DWORD>(GOOPDATE_E_NO_UPDATE_RESPONSE):
      event_log_text->AppendFormat(
          _T("App=%s, Ver=%s, Status=no-update\n"),
          GuidToString(app_data.app_guid()),
          app_data.version());
      if (is_update_) {
        // In case of updates, a "noupdate" response is not an error.
        result_type = PingEvent::EVENT_RESULT_NOUPDATE;
        info.status = COMPLETION_SUCCESS;
        info.error_code = NOERROR;

        AppManager app_manager(is_machine_);
        app_manager.ClearUpdateAvailableStats(app_data.parent_app_guid(),
                                              app_data.app_guid());
        app_manager.RecordSuccessfulUpdateCheck(app_data.parent_app_guid(),
                                                app_data.app_guid());
      }
      break;
    case static_cast<DWORD>(GOOPDATE_E_RESTRICTED_SERVER_RESPONSE):
      event_log_text->AppendFormat(
          _T("App=%s, Ver=%s, Status=restricted\n"),
          GuidToString(app_data.app_guid()),
          app_data.version());
      break;
    case GOOPDATE_E_UNKNOWN_APP_SERVER_RESPONSE:
    case GOOPDATE_E_INTERNAL_ERROR_SERVER_RESPONSE:
    case GOOPDATE_E_SERVER_RESPONSE_NO_HASH:
    case GOOPDATE_E_SERVER_RESPONSE_UNSUPPORTED_PROTOCOL:
    case GOOPDATE_E_UNKNOWN_SERVER_RESPONSE:
    default:
      event_log_text->AppendFormat(_T("App=%s, Ver=%s, Status=error:0x%08x\n"),
                                   GuidToString(app_data.app_guid()),
                                   app_data.version(),
                                   info.error_code);
      break;
  }

  // Only ping for server responses other than "noupdate" or errors.
  if (result_type != PingEvent::EVENT_RESULT_NOUPDATE ||
      info.error_code != NOERROR) {
    PingEvent::Types event_type = is_update_ ?
                                  PingEvent::EVENT_UPDATE_COMPLETE :
                                  PingEvent::EVENT_INSTALL_COMPLETE;
    PingEvent ping_event(event_type,
                         result_type,
                         info.error_code,
                         0,  // extra code 1
                         app_data.previous_version());
    ping_app_request_data->AddPingEvent(ping_event);
  }

  if (fail_if_update_not_available_) {
    *completion_info = info;
    return info.error_code;
  }

  return S_OK;
}

// app_name in UpdateResponseData is not filled in. See the TODO in that class.
CompletionInfo JobCreator::UpdateResponseDataToCompletionInfo(
    const UpdateResponseData& response_data,
    const CString& display_name) {
  CompletionInfo info;
  const CString& status = response_data.status();
  if (_tcsicmp(kResponseStatusOkValue, status) == 0) {
    info.status = COMPLETION_SUCCESS;
    info.error_code = 0;
  } else if (_tcsicmp(kResponseStatusNoUpdate, status) == 0) {
    // "noupdate" is considered an error but the calling code can map it to
    // a successful completion, in the cases of silent and on demand updates.
    info.status = COMPLETION_ERROR;
    info.error_code = static_cast<DWORD>(GOOPDATE_E_NO_UPDATE_RESPONSE);
    VERIFY1(info.text.LoadString(IDS_NO_UPDATE_RESPONSE));
  } else if (_tcsicmp(kResponseStatusRestrictedExportCountry, status) == 0) {
    // "restricted"
    info.status = COMPLETION_ERROR;
    info.error_code =
        static_cast<DWORD>(GOOPDATE_E_RESTRICTED_SERVER_RESPONSE);
    VERIFY1(info.text.LoadString(IDS_RESTRICTED_RESPONSE_FROM_SERVER));
  } else if (_tcsicmp(kResponseStatusUnKnownApplication, status) == 0) {
    // "error-UnKnownApplication"
    info.status = COMPLETION_ERROR;
    info.error_code =
        static_cast<DWORD>(GOOPDATE_E_UNKNOWN_APP_SERVER_RESPONSE);
    VERIFY1(info.text.LoadString(IDS_UNKNOWN_APPLICATION));
  } else if (_tcsicmp(kResponseStatusOsNotSupported, status) == 0) {
    // "error-OsNotSupported"
    info.status = COMPLETION_ERROR;
    info.error_code = static_cast<DWORD>(GOOPDATE_E_OS_NOT_SUPPORTED);
    if (response_data.error_url().IsEmpty()) {
      info.text.FormatMessage(IDS_NON_OK_RESPONSE_FROM_SERVER, status);
    } else {
      info.text.FormatMessage(IDS_OS_NOT_SUPPORTED,
                              display_name,
                              response_data.error_url());
    }
  } else if (_tcsicmp(kResponseStatusInternalError, status) == 0) {
    // "error-internal"
    info.status = COMPLETION_ERROR;
    info.error_code =
        static_cast<DWORD>(GOOPDATE_E_INTERNAL_ERROR_SERVER_RESPONSE);
    info.text.FormatMessage(IDS_NON_OK_RESPONSE_FROM_SERVER, status);
  } else if (_tcsicmp(kResponseStatusHashError, status) == 0) {
    // "error-hash"
    info.status = COMPLETION_ERROR;
    info.error_code =
        static_cast<DWORD>(GOOPDATE_E_SERVER_RESPONSE_NO_HASH);
    info.text.FormatMessage(IDS_NON_OK_RESPONSE_FROM_SERVER, status);
  } else if (_tcsicmp(kResponseStatusUnsupportedProtocol, status) == 0) {
    // "error-unsupportedprotocol"
    info.status = COMPLETION_ERROR;
    info.error_code =
        static_cast<DWORD>(GOOPDATE_E_SERVER_RESPONSE_UNSUPPORTED_PROTOCOL);
    // TODO(omaha): Ideally, we would provide an app-specific URL instead of
    // just the publisher name. If it was a link, we could use point to a
    // redirect URL and provide the app GUID rather than somehow obtaining the
    // app-specific URL.
    info.text.FormatMessage(IDS_INSTALLER_OLD, kPublisherName);
  } else {
    // Unknown response.
    info.status = COMPLETION_ERROR;
    info.error_code =
        static_cast<DWORD>(GOOPDATE_E_UNKNOWN_SERVER_RESPONSE);
    info.text.FormatMessage(IDS_NON_OK_RESPONSE_FROM_SERVER, status);
  }

  return info;
}

bool JobCreator::IsUpdateAvailable(const UpdateResponseData& response_data) {
  return _tcsicmp(kResponseStatusOkValue, response_data.status()) == 0;
}

// Check response and all of its children to see if any of them are in a state
// that requires an update job to be created.
bool JobCreator::IsUpdateAvailable(const UpdateResponse& response) {
  // If the top level response needs updating, short circuit here.
  if (IsUpdateAvailable(response.update_response_data())) {
    return true;
  }

  UpdateResponseDatas::const_iterator it;
  for (it = response.components_begin();
       it != response.components_begin();
       ++it) {
    if (IsUpdateAvailable(it->second)) {
      return true;
    }
  }

  return false;
}

}  // namespace omaha