(function() {
  /**
   * Repository listing page. Shows all repositories for all visibile namespaces.
   */
  angular.module('quayPages').config(['pages', function(pages) {
    pages.create('repo-list', 'repo-list.html', RepoListCtrl, {
      'newLayout': true,
      'title': 'Repositories',
      'description': 'View and manage Docker repositories'
    }, ['layout'])

    pages.create('repo-list', 'old-repo-list.html', OldRepoListCtrl, {
      'title': 'Repositories',
      'description': 'View and manage Docker repositories'
    }, ['old-layout']);
  }]);


  function RepoListCtrl($scope, $sanitize, $q, Restangular, UserService, ApiService) {
    $scope.allRepositories = {};
    $scope.loading = true;
    $scope.namespaces = [];
    $scope.namespaceMap = {};

    // When loading the UserService, if the user is logged in, create a list of
    // relevant namespaces and collect the relevant repositories.
    UserService.updateUserIn($scope, function(user) {
      $scope.loading = false;

      var addNamespace = function(namespace) {
        var name = namespace.username || namespace.name;
        var namespaceInfo = {
          'name': name,
          'avatar': namespace.avatar,
          'repositories': {
            'loading': true,
            'value': []
          }
        };

        $scope.namespaceMap[name] = namespaceInfo;
        $scope.namespaces.push(namespaceInfo);
      };

      if (!user.anonymous) {
        // Add our user to our list of namespaces.
        addNamespace(user);

        // Add each org to our list of namespaces.
        user.organizations.map(function(org) {
          addNamespace(org);
        });

        $scope.starred_repositories = {
          'loading': true,
          'value': []
        };

        // Load the repositories.
        loadRepos();
      }
    });

    $scope.isOrganization = function(namespace) {
      return !!UserService.getOrganization(namespace);
    };

    $scope.starToggled = function(repo) {
      if (repo.is_starred) {
        $scope.starred_repositories.value.push(repo);
      } else {
        $scope.starred_repositories.value = $scope.starred_repositories.value.filter(function(repo) {
          return repo.is_starred;
        });
      }
    };

    var loadRepos = function() {
      if (!$scope.user || $scope.user.anonymous || $scope.loading) {
        return;
      }

      var options = {
        'public': false,
        'sort': true
      };

      $scope.repositoriesResource = ApiService.listReposAsResource().withOptions(options).get(function(resp) {
        for (var i = 0; i < resp.repositories.length; ++i) {
          var repository = resp.repositories[i];
          var namespace = repository.namespace;
          var namespaceInfo = $scope.namespaceMap[namespace];
          if (!namespaceInfo) {
            continue;
          }

          namespaceInfo.repositories.value.push(repository);
          if (repository.is_starred) {
            $scope.starred_repositories.value.push(repository);
          }
        }

        for (var i = 0; i < $scope.namespaces.length; ++i) {
          var namespaceInfo = $scope.namespaces[i];
          namespaceInfo.repositories.loading = false;
        }

        $scope.starred_repositories.loading = false;
      });
    };
  }

  function OldRepoListCtrl($scope, $sanitize, Restangular, UserService, ApiService) {
    $scope.namespace = null;
    $scope.page = 1;
    $scope.publicPageCount = null;

    // Monitor changes in the user.
    UserService.updateUserIn($scope, function() {
      loadMyRepos($scope.namespace);
    });

    // Monitor changes in the namespace.
    $scope.$watch('namespace', function(namespace) {
      loadMyRepos(namespace);
    });

    $scope.movePublicPage = function(increment) {
      if ($scope.publicPageCount == null) {
        return;
      }

      $scope.page += increment;
      if ($scope.page < 1) {
        $scope.page = 1;
      }

      if ($scope.page > $scope.publicPageCount) {
        $scope.page = $scope.publicPageCount;
      }

      loadPublicRepos();
    };

    var loadMyRepos = function(namespace) {
      if (!$scope.user || $scope.user.anonymous || !namespace) {
        return;
      }

      var options = {'public': false, 'sort': true, 'namespace': namespace};

      $scope.user_repositories = ApiService.listReposAsResource().withOptions(options).get(function(resp) {
        return resp.repositories;
      });
    };

    var loadPublicRepos = function() {
      var options = {
        'public': true,
        'private': false,
        'sort': true,
        'limit': 10,
        'page': $scope.page,
        'count': $scope.page == 1
      };

      $scope.public_repositories = ApiService.listReposAsResource().withOptions(options).get(function(resp) {
        if (resp.count) {
          $scope.publicPageCount = Math.ceil(resp.count / 10);
        }
        return resp.repositories;
      });
    };

    loadPublicRepos();
  }
})();