// Copyright 2019 The Gitea Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.

package org

import (
	"strings"

	"code.gitea.io/gitea/services/repository"

	"code.gitea.io/gitea/modules/util"

	"code.gitea.io/gitea/models"
	"code.gitea.io/gitea/modules/base"
	"code.gitea.io/gitea/modules/context"
	"code.gitea.io/gitea/modules/setting"
)

const (
	tplOrgHome       base.TplName = "org/home"
	tplOrgCourseHome base.TplName = "org/home_courses"
)

// Home show organization home page
func Home(ctx *context.Context) {
	ctx.SetParams(":org", ctx.Params(":username"))
	ctx.Data["PageIsOrgHome"] = true
	context.HandleOrgAssignment(ctx)
	if ctx.Written() {
		return
	}

	org := ctx.Org.Organization

	if !models.HasOrgVisible(org, ctx.User) {
		ctx.NotFound("HasOrgVisible", nil)
		return
	}

	ctx.Data["Title"] = org.DisplayName()

	var orderBy models.SearchOrderBy
	ctx.Data["SortType"] = ctx.Query("sort")
	switch ctx.Query("sort") {
	case "newest":
		orderBy = models.SearchOrderByNewest
	case "oldest":
		orderBy = models.SearchOrderByOldest
	case "recentupdate":
		orderBy = models.SearchOrderByRecentUpdated
	case "leastupdate":
		orderBy = models.SearchOrderByLeastUpdated
	case "reversealphabetically":
		orderBy = models.SearchOrderByAlphabeticallyReverse
	case "alphabetically":
		orderBy = models.SearchOrderByAlphabetically
	case "moststars":
		orderBy = models.SearchOrderByStarsReverse
	case "feweststars":
		orderBy = models.SearchOrderByStars
	case "mostforks":
		orderBy = models.SearchOrderByForksReverse
	case "fewestforks":
		orderBy = models.SearchOrderByForks
	default:
		if setting.Course.OrgName == org.Name {
			ctx.Data["SortType"] = "newest"
			orderBy = models.SearchOrderByNewest

		} else {
			ctx.Data["SortType"] = "recentupdate"
			orderBy = models.SearchOrderByRecentUpdated
		}
	}
	orderBy = orderBy + ",id"
	keyword := strings.Trim(ctx.Query("q"), " ")
	ctx.Data["Keyword"] = keyword

	page := ctx.QueryInt("page")
	if page <= 0 {
		page = 1
	}

	var (
		repos []*models.Repository
		count int64
		err   error
	)
	pageSize := setting.UI.User.RepoPagingNum
	var CourseOptional util.OptionalBool = util.OptionalBoolNone
	if setting.Course.OrgName == org.Name {
		pageSize = 15
		recommendCourseKeyWords, _ := repository.GetRecommendCourseKeyWords()
		ctx.Data["CoursesKeywords"] = recommendCourseKeyWords

	} else {
		orgTopics, err := models.GetOrgTopics(org.ID)
		if err != nil {
			ctx.Error(500, "GetOrgTopics failed")
			return
		}
		ctx.Data["OrgTopics"] = orgTopics
	}

	repos, count, err = models.SearchRepository(&models.SearchRepoOptions{
		ListOptions: models.ListOptions{
			PageSize: pageSize,
			Page:     page,
		},
		Keyword:            keyword,
		OwnerID:            org.ID,
		OrderBy:            orderBy,
		Private:            ctx.IsSigned,
		Actor:              ctx.User,
		IncludeDescription: setting.UI.SearchRepoDescription,
		Course:             CourseOptional,
	})
	if err != nil {
		ctx.ServerError("SearchRepository", err)
		return
	}

	var opts = models.FindOrgMembersOpts{
		OrgID:       org.ID,
		PublicOnly:  true,
		ListOptions: models.ListOptions{Page: 1, PageSize: 25},
	}

	if ctx.User != nil {
		isMember, err := org.IsOrgMember(ctx.User.ID)
		if err != nil {
			ctx.Error(500, "IsOrgMember")
			return
		}
		opts.PublicOnly = !isMember && !ctx.User.IsAdmin
	}

	members, _, err := models.FindOrgMembers(&opts)
	if err != nil {
		ctx.ServerError("FindOrgMembers", err)
		return
	}

	membersCount, err := models.CountOrgMembers(opts)
	if err != nil {
		ctx.ServerError("CountOrgMembers", err)
		return
	}

	ctx.Data["Repos"] = repos
	ctx.Data["Total"] = count
	ctx.Data["MembersTotal"] = membersCount
	ctx.Data["Members"] = members
	ctx.Data["Teams"] = org.Teams

	pager := context.NewPagination(int(count), setting.UI.User.RepoPagingNum, page, 5)
	pager.SetDefaultParams(ctx)
	ctx.Data["Page"] = pager

	//find org tag info
	tags, err := models.GetAllOfficialTagRepos(org.ID, ctx.Org.IsOwner)

	if setting.Course.OrgName == org.Name {
		for _, tag := range tags {
			for _, repo := range tag.RepoList {
				repo.GetCreator()
				repo.GetOwner()
			}
		}

	}

	if err != nil {
		ctx.ServerError("GetAllOfficialTagRepos", err)
		return
	}

	ctx.Data["tags"] = tags
	if setting.Course.OrgName == org.Name {
		ctx.HTML(200, tplOrgCourseHome)
	} else {
		ctx.HTML(200, tplOrgHome)
	}

}