package service

import (
	"context"
	"fmt"
	v1 "github.com/go-nunu/nunu-layout-advanced/api/v1"
	"github.com/go-nunu/nunu-layout-advanced/internal/model"
	"github.com/go-nunu/nunu-layout-advanced/internal/repository"
	"github.com/spf13/cast"
	"strconv"
)

type TcpforwardingService interface {
	GetTcpforwarding(ctx context.Context, id int64) (*model.Tcpforwarding, error)
	AddTcpForwarding(ctx context.Context, req *v1.TcpForwardingRequest)  error
	EditTcpForwarding(ctx context.Context, req *v1.TcpForwardingRequest) (string, error)
	DeleteTcpForwarding(ctx context.Context, wafTcpId int) (string, error)
}

func NewTcpforwardingService(
	service *Service,
	tcpforwardingRepository repository.TcpforwardingRepository,
	parser ParserService,
	required RequiredService,
	crawler CrawlerService,
	globalRep repository.GlobalLimitRepository,
	hostRep repository.HostRepository,
	wafformatter WafFormatterService,
) TcpforwardingService {
	return &tcpforwardingService{
		Service:                 service,
		tcpforwardingRepository: tcpforwardingRepository,
		parser:                  parser,
		required:                required,
		crawler:                 crawler,
		globalRep:               globalRep,
		hostRep:                 hostRep,
		wafformatter:            wafformatter,
	}
}

type tcpforwardingService struct {
	*Service
	tcpforwardingRepository repository.TcpforwardingRepository
	parser                  ParserService
	required                RequiredService
	crawler                 CrawlerService
	globalRep               repository.GlobalLimitRepository
	hostRep      repository.HostRepository
	wafformatter WafFormatterService
}

func (s *tcpforwardingService) GetTcpforwarding(ctx context.Context, id int64) (*model.Tcpforwarding, error) {
	return s.tcpforwardingRepository.GetTcpforwarding(ctx, id)
}

func (s *tcpforwardingService) require(ctx context.Context,req v1.GlobalRequire) (v1.GlobalRequire, error) {
	res, err := s.wafformatter.require(ctx, req, "tcp")
	if err != nil {
		return v1.GlobalRequire{}, err
	}
	return res, nil
}

func (s *tcpforwardingService) AddTcpForwarding(ctx context.Context, req *v1.TcpForwardingRequest)  error {
	require, err := s.require(ctx, v1.GlobalRequire{
		HostId: req.HostId,
		Uid:    req.Uid,
		Comment: req.TcpForwardingData.Comment,
	})
	if err != nil {
		return  err
	}
	formData := map[string]interface{}{
		"tag":                  require.Tag,
		"port":                 req.TcpForwardingData.Port,
		"waf_gateway_group_id": require.WafGatewayGroupId,
		"waf_tcp_limit_id": 	require.LimitRuleId,
		"cc_count":             req.TcpForwardingData.CcCount,
		"cc_duration":          req.TcpForwardingData.CcDuration,
		"cc_block_count":       req.TcpForwardingData.CcBlockCount,
		"cc_block_duration":    req.TcpForwardingData.CcBlockDuration,
		"backend_protocol":     req.TcpForwardingData.BackendProtocol,
		"backend_timeout":      req.TcpForwardingData.BackendTimeout,
		"comment":              req.TcpForwardingData.Comment,
		"backend_list":         req.TcpForwardingData.BackendList,
		"allow_ip_list":        req.TcpForwardingData.AllowIpList,
		"deny_ip_list":         req.TcpForwardingData.DenyIpList,
		"access_rule":          req.TcpForwardingData.AccessRule,
	}
	respBody, err := s.required.SendForm(ctx, "admin/info/waf_tcp/new", "admin/new/waf_tcp", formData)
	if err != nil {
		return err
	}
	// 解析响应内容中的 alert 消息
	res, err := s.parser.ParseAlert(string(respBody))
	if err != nil {
		return err
	}
	if res != "" {
		return fmt.Errorf(res)
	}
	wafTcpIdStr, err := s.parser.GetRuleId(ctx, respBody)
	if err != nil {
		return err
	}
	wafTcpId, err := cast.ToIntE(wafTcpIdStr)
	if err != nil {
		return err
	}

	if err = s.tcpforwardingRepository.AddTcpforwarding(ctx, &model.Tcpforwarding{
		HostId:  req.HostId,
		RuleId: wafTcpId,
		Port: strconv.Itoa(req.TcpForwardingData.Port),
		Tag:     require.Tag,
		Comment: req.TcpForwardingData.Comment,
		WafGatewayGroupId: require.WafGatewayGroupId,
		CcCount: req.TcpForwardingData.CcCount,
		CcDuration: req.TcpForwardingData.CcDuration,
		CcBlockCount: req.TcpForwardingData.CcBlockCount,
		CcBlockDuration: req.TcpForwardingData.CcBlockDuration,
		BackendProtocol: req.TcpForwardingData.BackendProtocol,
		BackendTimeout: req.TcpForwardingData.BackendTimeout,
	}) ; err != nil {
		return err
	}
	return  nil
}

func (s *tcpforwardingService) EditTcpForwarding(ctx context.Context, req *v1.TcpForwardingRequest) (string, error) {
	require, err := s.require(ctx, v1.GlobalRequire{
		HostId: req.HostId,
		Uid:    req.Uid,
		Comment: req.TcpForwardingData.Comment,
	})
	if err != nil {
		return "", err
	}
	formData := map[string]interface{}{
		"tag":                  require.Tag,
		"port":                 req.TcpForwardingData.Port,
		"waf_gateway_group_id": require.WafGatewayGroupId,
		"waf_tcp_limit_id": 	require.LimitRuleId,
		"cc_count":             req.TcpForwardingData.CcCount,
		"cc_duration":          req.TcpForwardingData.CcDuration,
		"cc_block_count":       req.TcpForwardingData.CcBlockCount,
		"cc_block_duration":    req.TcpForwardingData.CcBlockDuration,
		"backend_protocol":     req.TcpForwardingData.BackendProtocol,
		"backend_timeout":      req.TcpForwardingData.BackendTimeout,
		"comment":              req.TcpForwardingData.Comment,
		"backend_list":         req.TcpForwardingData.BackendList,
		"allow_ip_list":        req.TcpForwardingData.AllowIpList,
		"deny_ip_list":         req.TcpForwardingData.DenyIpList,
		"access_rule":          req.TcpForwardingData.AccessRule,
	}
	respBody, err := s.required.SendForm(ctx, "admin/info/waf_tcp/edit?&__goadmin_edit_pk="+strconv.Itoa(req.TcpForwardingData.WafTcpId), "admin/edit/waf_tcp", formData)
	if err != nil {
		return "", err
	}
	// 解析响应内容中的 alert 消息
	res, err := s.parser.ParseAlert(string(respBody))
	if err != nil {
		return "", err
	}
	if res != "" {
		return "", fmt.Errorf(res)
	}
	return "", nil
}

func (s *tcpforwardingService) DeleteTcpForwarding(ctx context.Context, wafTcpId int) (string, error) {
	res, err := s.crawler.DeleteRule(ctx, wafTcpId, "admin/delete/waf_tcp?page=1&__pageSize=10&__sort=waf_tcp_id&__sort_type=desc")
	if err != nil {
		return "", err
	}
	return res, nil
}