import _ from 'lodash-es';
import { RepositoryShortTag } from '../models/repositoryTag';
import { RepositoryAddTagPayload } from '../models/repositoryTag'
import { RegistryRepositoryViewModel } from '../models/registryRepository';
import genericAsyncGenerator from './genericAsyncGenerator';

angular.module('portainer.extensions.registrymanagement')
.factory('RegistryV2Service', ['$q', '$async', 'RegistryCatalog', 'RegistryTags', 'RegistryManifestsJquery', 'RegistryV2Helper',
function RegistryV2ServiceFactory($q, $async, RegistryCatalog, RegistryTags, RegistryManifestsJquery, RegistryV2Helper) {
  'use strict';
  var service = {};

  /**
   * PING
   */
  function ping(registry, forceNewConfig) {
    const id = registry.Id;
    if (forceNewConfig) {
      return RegistryCatalog.pingWithForceNew({ id: id }).$promise;
    }
    return RegistryCatalog.ping({ id: id }).$promise;
  }

  /**
   * END PING
   */

  /**
   * REPOSITORIES
   */

  function _getCatalogPage(params, deferred, repositories) {
    RegistryCatalog.get(params).$promise.then(function(data) {
      repositories = _.concat(repositories, data.repositories);
      if (data.last && data.n) {
        _getCatalogPage({id: params.id, n: data.n, last: data.last}, deferred, repositories);
      } else {
        deferred.resolve(repositories);
      }
    });
  }

  function _getCatalog(id) {
    var deferred = $q.defer();
    var repositories = [];

    _getCatalogPage({id: id}, deferred, repositories);
    return deferred.promise;
  }

  function repositories(registry) {
    const deferred = $q.defer();
    const id = registry.Id;

    _getCatalog(id).then(function success(data) {
      const repositories = _.map(data, (repositoryName) => new RegistryRepositoryViewModel(repositoryName));
      deferred.resolve(repositories);
    })
    .catch(function error(err) {
      deferred.reject({
        msg: 'Unable to retrieve repositories',
        err: err
      });
    });

    return deferred.promise;
  }

  function getRepositoriesDetails(registry, repositories) {
    const deferred = $q.defer();
    const promises = _.map(repositories, (repository) => tags(registry, repository.Name));

    $q.all(promises)
    .then(function success(data) {
      var repositories = data.map(function (item) {
        return new RegistryRepositoryViewModel(item);
      });
      repositories = _.without(repositories, undefined);
      deferred.resolve(repositories);
    })
    .catch(function error(err) {
      deferred.reject({
        msg: 'Unable to retrieve repositories',
        err: err
      });
    });

    return deferred.promise;
  }

  /**
   * END REPOSITORIES
   */

  /**
   * TAGS
   */

  function _getTagsPage(params, deferred, previousTags) {
    RegistryTags.get(params).$promise.then(function(data) {
      previousTags.name = data.name;
      previousTags.tags = _.concat(previousTags.tags, data.tags);
      if (data.last && data.n) {
        _getTagsPage({id: params.id, repository: params.repository, n: data.n, last: data.last}, deferred, previousTags);
      } else {
        deferred.resolve(previousTags);
      }
    }).catch(function error(err) {
      deferred.reject({
        msg: 'Unable to retrieve tags',
        err: err
      });
    });
  }

  function tags(registry, repository) {
    const deferred = $q.defer();
    const id = registry.Id;

    _getTagsPage({id: id, repository: repository}, deferred, {tags:[]});
    return deferred.promise;
  }

  function getTagsDetails(registry, repository, tags) {
    const promises = _.map(tags, (t) => tag(registry, repository, t.Name));

    return $q.all(promises);
  }

  function tag(registry, repository, tag) {
    const deferred = $q.defer();
    const id = registry.Id;

    var promises = {
      v1: RegistryManifestsJquery.get({
        id: id,
        repository: repository,
        tag: tag
      }),
      v2: RegistryManifestsJquery.getV2({
        id: id,
        repository: repository,
        tag: tag
      })
    };
    $q.all(promises)
    .then(function success(data) {
      var tag = RegistryV2Helper.manifestsToTag(data);
      deferred.resolve(tag);
    }).catch(function error(err) {
      deferred.reject({
        msg: 'Unable to retrieve tag ' + tag,
        err: err
      });
    });

    return deferred.promise;
  }

  /**
   * END TAGS
   */

  /**
   * ADD TAG
   */

  // tag: RepositoryAddTagPayload
  function _addTagFromGenerator(registry, repository, tag) {
    return addTag(registry, repository, tag.Tag, tag.Manifest);
  }

  function addTag(registry, repository, tag, manifest) {
    const id = registry.Id;
    delete manifest.digest;
    return RegistryManifestsJquery.put({
      id: id,
      repository: repository,
      tag: tag
    }, manifest);
  }

  async function* _addTagsWithProgress(registry, repository, tagsList, progression = 0) {
    for await (const partialResult of genericAsyncGenerator($q, tagsList, _addTagFromGenerator, [registry, repository])) {
      if (typeof partialResult === 'number') {
        yield progression + partialResult;
      } else {
        yield partialResult;
      }
    }
  }

  /**
   * END ADD TAG
   */

  /**
   * DELETE MANIFEST
   */

  function deleteManifest(registry, repository, imageDigest) {
    const id = registry.Id;
    return RegistryManifestsJquery.delete({
      id: id,
      repository: repository,
      tag: imageDigest
    });
  }

  async function* _deleteManifestsWithProgress(registry, repository, manifests) {
    for await (const partialResult of genericAsyncGenerator($q, manifests, deleteManifest, [registry, repository])) {
      yield partialResult;
    }
  }

  /**
   * END DELETE MANIFEST
   */

  /**
   * SHORT TAG
   */

  function _shortTagFromGenerator(id, repository, tag) {
    return new Promise ((resolve, reject) => {
      RegistryManifestsJquery.getV2({id:id, repository: repository, tag: tag})
      .then((data) => resolve(new RepositoryShortTag(tag, data.config.digest, data.digest, data)))
      .catch((err) => reject(err))
    });
  }

  async function* shortTagsWithProgress(registry, repository, tagsList) {
    const id = registry.Id;
    yield* genericAsyncGenerator($q, tagsList, _shortTagFromGenerator, [id, repository]);
  }

  /**
   * END SHORT TAG
   */

  /**
   * RETAG
   */
  async function* retagWithProgress(registry, repository, modifiedTags, modifiedDigests, impactedTags){
    yield* _deleteManifestsWithProgress(registry, repository, modifiedDigests);

    const newTags = _.map(impactedTags, (item) => {
      const tagFromTable = _.find(modifiedTags, { 'Name': item.Name });
      const name = tagFromTable && tagFromTable.Name !== tagFromTable.NewName ? tagFromTable.NewName : item.Name;
      return new RepositoryAddTagPayload(name, item.ManifestV2);
    });

    yield* _addTagsWithProgress(registry, repository, newTags, modifiedDigests.length);
  }

  /**
   * END RETAG
   */

  /**
   * DELETE TAGS
   */

  async function* deleteTagsWithProgress(registry, repository, modifiedDigests, impactedTags) {
    yield* _deleteManifestsWithProgress(registry, repository, modifiedDigests);

    const newTags = _.map(impactedTags, (item) => new RepositoryAddTagPayload(item.Name, item.ManifestV2));

    yield* _addTagsWithProgress(registry, repository, newTags, modifiedDigests.length);
  }

  /**
   * END DELETE TAGS
   */

  /**
   * SERVICE FUNCTIONS DECLARATION
   */

  service.ping = ping;

  service.repositories = repositories;
  service.getRepositoriesDetails = getRepositoriesDetails;

  service.tags = tags;
  service.tag = tag;
  service.getTagsDetails = getTagsDetails;

  service.shortTagsWithProgress = shortTagsWithProgress;

  service.addTag = addTag;
  service.deleteManifest = deleteManifest;

  service.deleteTagsWithProgress = deleteTagsWithProgress;
  service.retagWithProgress = retagWithProgress;

  return service;
}
]);