package api

import (
	"context"
	"strconv"

	"next-terminal/server/common/maps"
	"next-terminal/server/model"
	"next-terminal/server/repository"
	"next-terminal/server/utils"

	"github.com/labstack/echo/v4"
)

type AuthorisedAssetApi struct{}

func (api AuthorisedAssetApi) PagingEndpoint(c echo.Context) error {
	pageIndex, _ := strconv.Atoi(c.QueryParam("pageIndex"))
	pageSize, _ := strconv.Atoi(c.QueryParam("pageSize"))
	userId := c.QueryParam("userId")
	departmentId := c.QueryParam("departmentId")
	assetGroupId := c.QueryParam("assetGroupId")
	assetId := c.QueryParam("assetId")

	items, total, err := repository.AuthorisedAssetRepository.FindWithDetails(context.TODO(), pageIndex, pageSize, userId, departmentId, assetGroupId, assetId)
	if err != nil {
		return err
	}

	if items == nil {
		items = []map[string]interface{}{}
	}

	return Success(c, maps.Map{
		"total": total,
		"items": items,
	})
}

func (api AuthorisedAssetApi) AuthorisedAssetsEndpoint(c echo.Context) error {
	var req struct {
		UserIds         []string `json:"userIds"`
		DepartmentIds   []string `json:"departmentIds"`
		AssetIds        []string `json:"assetIds"`
		AssetGroupIds   []string `json:"assetGroupIds"`
		CommandFilterId string   `json:"commandFilterId"`
		StrategyId      string   `json:"strategyId"`
		ExpiredAt       int64    `json:"expiredAt"`
	}
	if err := c.Bind(&req); err != nil {
		return err
	}

	var items []model.AuthorisedAsset
	for _, userId := range req.UserIds {
		for _, assetId := range req.AssetIds {
			items = append(items, model.AuthorisedAsset{
				ID:              utils.UUID(),
				UserId:          userId,
				AssetId:         assetId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
		for _, assetGroupId := range req.AssetGroupIds {
			items = append(items, model.AuthorisedAsset{
				ID:              utils.UUID(),
				UserId:          userId,
				AssetGroupId:    assetGroupId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
	}
	for _, departmentId := range req.DepartmentIds {
		for _, assetId := range req.AssetIds {
			items = append(items, model.AuthorisedAsset{
				ID:              utils.UUID(),
				DepartmentId:    departmentId,
				AssetId:         assetId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
		for _, assetGroupId := range req.AssetGroupIds {
			items = append(items, model.AuthorisedAsset{
				ID:              utils.UUID(),
				DepartmentId:    departmentId,
				AssetGroupId:    assetGroupId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
	}

	if len(items) > 0 {
		if err := repository.AuthorisedAssetRepository.CreateInBatches(context.TODO(), items); err != nil {
			return err
		}
	}

	return Success(c, nil)
}

func (api AuthorisedAssetApi) AuthorisedUsersEndpoint(c echo.Context) error {
	var req struct {
		AssetIds        []string `json:"assetIds"`
		AssetGroupIds   []string `json:"assetGroupIds"`
		UserIds         []string `json:"userIds"`
		CommandFilterId string   `json:"commandFilterId"`
		StrategyId      string   `json:"strategyId"`
		ExpiredAt       int64    `json:"expiredAt"`
	}
	if err := c.Bind(&req); err != nil {
		return err
	}

	var items []model.AuthorisedAsset
	for _, userId := range req.UserIds {
		for _, assetId := range req.AssetIds {
			items = append(items, model.AuthorisedAsset{
				ID:              utils.UUID(),
				UserId:          userId,
				AssetId:         assetId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
		for _, assetGroupId := range req.AssetGroupIds {
			items = append(items, model.AuthorisedAsset{
				ID:              utils.UUID(),
				UserId:          userId,
				AssetGroupId:    assetGroupId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
	}

	if len(items) > 0 {
		if err := repository.AuthorisedAssetRepository.CreateInBatches(context.TODO(), items); err != nil {
			return err
		}
	}

	return Success(c, nil)
}

func (api AuthorisedAssetApi) AuthorisedDepartmentsEndpoint(c echo.Context) error {
	var req struct {
		AssetIds        []string `json:"assetIds"`
		AssetGroupIds   []string `json:"assetGroupIds"`
		DepartmentIds   []string `json:"departmentIds"`
		CommandFilterId string   `json:"commandFilterId"`
		StrategyId      string   `json:"strategyId"`
		ExpiredAt       int64    `json:"expiredAt"`
	}
	if err := c.Bind(&req); err != nil {
		return err
	}

	var items []model.AuthorisedAsset
	for _, departmentId := range req.DepartmentIds {
		for _, assetId := range req.AssetIds {
			items = append(items, model.AuthorisedAsset{
				ID:              utils.UUID(),
				DepartmentId:    departmentId,
				AssetId:         assetId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
		for _, assetGroupId := range req.AssetGroupIds {
			items = append(items, model.AuthorisedAsset{
				ID:              utils.UUID(),
				DepartmentId:    departmentId,
				AssetGroupId:    assetGroupId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
	}

	if len(items) > 0 {
		if err := repository.AuthorisedAssetRepository.CreateInBatches(context.TODO(), items); err != nil {
			return err
		}
	}

	return Success(c, nil)
}

func (api AuthorisedAssetApi) SelectedEndpoint(c echo.Context) error {
	expect := c.QueryParam("expect")
	userId := c.QueryParam("userId")
	departmentId := c.QueryParam("departmentId")
	assetId := c.QueryParam("assetId")

	result, err := repository.AuthorisedAssetRepository.Selected(context.TODO(), expect, userId, departmentId, assetId)
	if err != nil {
		return err
	}
	return Success(c, result)
}

func (api AuthorisedAssetApi) DeleteEndpoint(c echo.Context) error {
	id := c.Param("id")
	if err := repository.AuthorisedAssetRepository.DeleteById(context.TODO(), id); err != nil {
		return err
	}
	return Success(c, nil)
}

func (api AuthorisedAssetApi) GetEndpoint(c echo.Context) error {
	id := c.Param("id")
	item, err := repository.AuthorisedAssetRepository.FindById(context.TODO(), id)
	if err != nil {
		return err
	}
	return Success(c, item)
}

func (api AuthorisedAssetApi) UpdateEndpoint(c echo.Context) error {
	id := c.Param("id")
	var item model.AuthorisedAsset
	if err := c.Bind(&item); err != nil {
		return err
	}
	item.ID = id
	if err := repository.AuthorisedAssetRepository.UpdateById(context.TODO(), &item); err != nil {
		return err
	}
	return Success(c, item)
}

func (api AuthorisedAssetApi) CreateEndpoint(c echo.Context) error {
	var req struct {
		UserIds         []string `json:"userIds"`
		DepartmentIds   []string `json:"departmentIds"`
		AssetIds        []string `json:"assetIds"`
		AssetGroupIds   []string `json:"assetGroupIds"`
		CommandFilterId string   `json:"commandFilterId"`
		StrategyId      string   `json:"strategyId"`
		ExpiredAt       int64    `json:"expiredAt"`
	}
	if err := c.Bind(&req); err != nil {
		return err
	}

	var items []model.AuthorisedAsset
	for _, userId := range req.UserIds {
		for _, assetId := range req.AssetIds {
			items = append(items, model.AuthorisedAsset{
				ID:              utils.UUID(),
				UserId:          userId,
				AssetId:         assetId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
		for _, assetGroupId := range req.AssetGroupIds {
			items = append(items, model.AuthorisedAsset{
				ID:              utils.UUID(),
				UserId:          userId,
				AssetGroupId:    assetGroupId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
	}
	for _, departmentId := range req.DepartmentIds {
		for _, assetId := range req.AssetIds {
			items = append(items, model.AuthorisedAsset{
				ID:              utils.UUID(),
				DepartmentId:    departmentId,
				AssetId:         assetId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
		for _, assetGroupId := range req.AssetGroupIds {
			items = append(items, model.AuthorisedAsset{
				ID:              utils.UUID(),
				DepartmentId:    departmentId,
				AssetGroupId:    assetGroupId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
	}

	if len(items) > 0 {
		if err := repository.AuthorisedAssetRepository.CreateInBatches(context.TODO(), items); err != nil {
			return err
		}
	}

	return Success(c, nil)
}

type AuthorisedDatabaseAssetApi struct{}

func (api AuthorisedDatabaseAssetApi) PagingEndpoint(c echo.Context) error {
	pageIndex, _ := strconv.Atoi(c.QueryParam("pageIndex"))
	pageSize, _ := strconv.Atoi(c.QueryParam("pageSize"))
	userId := c.QueryParam("userId")
	departmentId := c.QueryParam("departmentId")
	databaseAssetId := c.QueryParam("assetId")

	items, total, err := repository.AuthorisedDatabaseAssetRepository.FindWithDetails(context.TODO(), pageIndex, pageSize, userId, departmentId, databaseAssetId)
	if err != nil {
		return err
	}

	if items == nil {
		items = []map[string]interface{}{}
	}

	return Success(c, maps.Map{
		"total": total,
		"items": items,
	})
}

func (api AuthorisedDatabaseAssetApi) SelectedEndpoint(c echo.Context) error {
	expect := c.QueryParam("expect")
	userId := c.QueryParam("userId")
	departmentId := c.QueryParam("departmentId")
	databaseAssetId := c.QueryParam("assetId")

	result, err := repository.AuthorisedDatabaseAssetRepository.Selected(context.TODO(), expect, userId, departmentId, databaseAssetId)
	if err != nil {
		return err
	}
	return Success(c, result)
}

func (api AuthorisedDatabaseAssetApi) DeleteEndpoint(c echo.Context) error {
	id := c.Param("id")
	if err := repository.AuthorisedDatabaseAssetRepository.DeleteById(context.TODO(), id); err != nil {
		return err
	}
	return Success(c, nil)
}

func (api AuthorisedDatabaseAssetApi) GetEndpoint(c echo.Context) error {
	id := c.Param("id")
	item, err := repository.AuthorisedDatabaseAssetRepository.FindById(context.TODO(), id)
	if err != nil {
		return err
	}
	return Success(c, item)
}

func (api AuthorisedDatabaseAssetApi) UpdateEndpoint(c echo.Context) error {
	id := c.Param("id")
	var item model.AuthorisedDatabaseAsset
	if err := c.Bind(&item); err != nil {
		return err
	}
	item.ID = id
	if err := repository.AuthorisedDatabaseAssetRepository.UpdateById(context.TODO(), &item); err != nil {
		return err
	}
	return Success(c, item)
}

func (api AuthorisedDatabaseAssetApi) CreateEndpoint(c echo.Context) error {
	var req struct {
		UserIds          []string `json:"userIds"`
		DepartmentIds    []string `json:"departmentIds"`
		DatabaseAssetIds []string `json:"assetIds"`
		CommandFilterId  string   `json:"commandFilterId"`
		StrategyId       string   `json:"strategyId"`
		ExpiredAt        int64    `json:"expiredAt"`
	}
	if err := c.Bind(&req); err != nil {
		return err
	}

	var items []model.AuthorisedDatabaseAsset
	for _, userId := range req.UserIds {
		for _, databaseAssetId := range req.DatabaseAssetIds {
			items = append(items, model.AuthorisedDatabaseAsset{
				ID:              utils.UUID(),
				UserId:          userId,
				DatabaseAssetId: databaseAssetId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
	}
	for _, departmentId := range req.DepartmentIds {
		for _, databaseAssetId := range req.DatabaseAssetIds {
			items = append(items, model.AuthorisedDatabaseAsset{
				ID:              utils.UUID(),
				DepartmentId:    departmentId,
				DatabaseAssetId: databaseAssetId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
	}

	if len(items) > 0 {
		if err := repository.AuthorisedDatabaseAssetRepository.CreateInBatches(context.TODO(), items); err != nil {
			return err
		}
	}

	return Success(c, nil)
}

type AuthorisedWebsiteApi struct{}

func (api AuthorisedWebsiteApi) PagingEndpoint(c echo.Context) error {
	pageIndex, _ := strconv.Atoi(c.QueryParam("pageIndex"))
	pageSize, _ := strconv.Atoi(c.QueryParam("pageSize"))
	userId := c.QueryParam("userId")
	departmentId := c.QueryParam("departmentId")
	websiteId := c.QueryParam("websiteId")

	items, total, err := repository.AuthorisedWebsiteRepository.FindWithDetails(context.TODO(), pageIndex, pageSize, userId, departmentId, websiteId)
	if err != nil {
		return err
	}

	if items == nil {
		items = []map[string]interface{}{}
	}

	return Success(c, maps.Map{
		"total": total,
		"items": items,
	})
}

func (api AuthorisedWebsiteApi) DeleteEndpoint(c echo.Context) error {
	id := c.Param("id")
	if err := repository.AuthorisedWebsiteRepository.DeleteById(context.TODO(), id); err != nil {
		return err
	}
	return Success(c, nil)
}

func (api AuthorisedWebsiteApi) CreateEndpoint(c echo.Context) error {
	var req struct {
		UserIds         []string `json:"userIds"`
		DepartmentIds   []string `json:"departmentIds"`
		WebsiteIds      []string `json:"websiteIds"`
		CommandFilterId string   `json:"commandFilterId"`
		StrategyId      string   `json:"strategyId"`
		ExpiredAt       int64    `json:"expiredAt"`
	}
	if err := c.Bind(&req); err != nil {
		return err
	}

	var items []model.AuthorisedWebsite
	for _, userId := range req.UserIds {
		for _, websiteId := range req.WebsiteIds {
			items = append(items, model.AuthorisedWebsite{
				ID:              utils.UUID(),
				UserId:          userId,
				WebsiteId:       websiteId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
	}
	for _, departmentId := range req.DepartmentIds {
		for _, websiteId := range req.WebsiteIds {
			items = append(items, model.AuthorisedWebsite{
				ID:              utils.UUID(),
				DepartmentId:    departmentId,
				WebsiteId:       websiteId,
				CommandFilterId: req.CommandFilterId,
				StrategyId:      req.StrategyId,
				ExpiredAt:       req.ExpiredAt,
			})
		}
	}

	if len(items) > 0 {
		if err := repository.AuthorisedWebsiteRepository.CreateInBatches(context.TODO(), items); err != nil {
			return err
		}
	}

	return Success(c, nil)
}

type DbWorkOrderApi struct{}

func (api DbWorkOrderApi) PagingEndpoint(c echo.Context) error {
	return Success(c, maps.Map{
		"total": 0,
		"items": []interface{}{},
	})
}

func (api DbWorkOrderApi) GetEndpoint(c echo.Context) error {
	return Success(c, nil)
}

func (api DbWorkOrderApi) CreateEndpoint(c echo.Context) error {
	return Success(c, nil)
}

func (api DbWorkOrderApi) ApproveEndpoint(c echo.Context) error {
	return Success(c, nil)
}

func (api DbWorkOrderApi) RejectEndpoint(c echo.Context) error {
	return Success(c, nil)
}

func (api DbWorkOrderApi) DeleteEndpoint(c echo.Context) error {
	return Success(c, nil)
}

type DatabaseSQLLogApi struct{}

func (api DatabaseSQLLogApi) PagingEndpoint(c echo.Context) error {
	pageIndex, _ := strconv.Atoi(c.QueryParam("pageIndex"))
	pageSize, _ := strconv.Atoi(c.QueryParam("pageSize"))
	assetId := c.QueryParam("assetId")
	userId := c.QueryParam("userId")
	status := c.QueryParam("status")
	source := c.QueryParam("source")
	order := c.QueryParam("order")
	field := c.QueryParam("field")

	items, total, err := repository.DatabaseSQLLogRepository.FindByPage(context.TODO(), pageIndex, pageSize, assetId, userId, status, source, order, field)
	if err != nil {
		return err
	}

	result := make([]maps.Map, 0)
	for _, item := range items {
		var assetName, userName string
		if item.AssetId != "" {
			asset, _ := repository.DatabaseAssetRepository.FindById(context.TODO(), item.AssetId)
			assetName = asset.Name
		}
		if item.UserId != "" {
			user, _ := repository.UserRepository.FindById(context.TODO(), item.UserId)
			userName = user.Username
		}
		result = append(result, maps.Map{
			"id":           item.ID,
			"assetId":      item.AssetId,
			"assetName":    assetName,
			"database":     item.Database,
			"userId":       item.UserId,
			"userName":     userName,
			"clientIp":     item.ClientIP,
			"sql":          item.SQL,
			"durationMs":   item.DurationMs,
			"rowsAffected": item.RowsAffected,
			"status":       item.Status,
			"errorMessage": item.ErrorMessage,
			"source":       item.Source,
			"createdAt":    item.Created,
		})
	}

	return Success(c, maps.Map{
		"total": total,
		"items": result,
	})
}

func (api DatabaseSQLLogApi) ClearEndpoint(c echo.Context) error {
	if err := repository.DatabaseSQLLogRepository.DeleteAll(context.TODO()); err != nil {
		return err
	}
	return Success(c, nil)
}

type DnsProviderApi struct{}

func (api DnsProviderApi) GetConfigEndpoint(c echo.Context) error {
	return Success(c, maps.Map{
		"ok":    false,
		"email": "",
		"type":  "",
	})
}

func (api DnsProviderApi) SetConfigEndpoint(c echo.Context) error {
	return Success(c, nil)
}

func (api DnsProviderApi) DeleteConfigEndpoint(c echo.Context) error {
	return Success(c, nil)
}

type LicenseApi struct{}

func (api LicenseApi) GetMachineIdEndpoint(c echo.Context) error {
	return Success(c, maps.Map{
		"machineId": "",
	})
}

func (api LicenseApi) GetLicenseEndpoint(c echo.Context) error {
	return Success(c, maps.Map{
		"type":       "free",
		"machineId":  "",
		"asset":      0,
		"concurrent": 0,
		"user":       0,
		"expired":    0,
	})
}

func (api LicenseApi) GetSimpleLicenseEndpoint(c echo.Context) error {
	return Success(c, maps.Map{
		"type":    "free",
		"expired": 0,
		"oem":     false,
	})
}

func (api LicenseApi) SetLicenseEndpoint(c echo.Context) error {
	return Success(c, nil)
}

func (api LicenseApi) RequestLicenseEndpoint(c echo.Context) error {
	return Success(c, nil)
}

type OidcApi struct{}

func (api OidcApi) AuthorizeEndpoint(c echo.Context) error {
	return Success(c, maps.Map{
		"authorizeUrl": "",
		"state":        "",
	})
}

func (api OidcApi) LoginEndpoint(c echo.Context) error {
	return Success(c, maps.Map{
		"token":    "",
		"needTotp": false,
	})
}

type WechatWorkApi struct{}

func (api WechatWorkApi) AuthorizeEndpoint(c echo.Context) error {
	return Success(c, maps.Map{
		"authorizeUrl": "",
	})
}

func (api WechatWorkApi) LoginEndpoint(c echo.Context) error {
	return Success(c, maps.Map{
		"token":    "",
		"needTotp": false,
	})
}

type WebsiteTempAllowApi struct{}

func (api WebsiteTempAllowApi) ListEndpoint(c echo.Context) error {
	return Success(c, []interface{}{})
}

func (api WebsiteTempAllowApi) DeleteEndpoint(c echo.Context) error {
	return Success(c, nil)
}