package gitctl

import (
	"context"
	"fmt"
	"net/http"
	"time"

	"connectrpc.com/connect"
	"google.golang.org/protobuf/types/known/emptypb"

	v1 "simplegit/gitrpc/v1"
	"simplegit/gitrpc/v1/v1connect"
)

type manageClient struct {
	c       v1connect.ManageServiceClient
	baseURL string
	http    *http.Client
}

func newManageClient(baseURL string) *manageClient {
	return &manageClient{
		c:       v1connect.NewManageServiceClient(&http.Client{Timeout: 15 * time.Second}, baseURL),
		baseURL: baseURL,
		http:    &http.Client{Timeout: 15 * time.Second},
	}
}

func (m *manageClient) ping() bool {
	cli := &http.Client{Timeout: 2 * time.Second}
	resp, err := cli.Get(m.baseURL + "/")
	if err != nil {
		return false
	}
	_ = resp.Body.Close()
	return true
}

func errText(err error) string {
	if err == nil {
		return ""
	}
	code := connect.CodeOf(err)
	if code == connect.CodeUnknown {
		return err.Error()
	}
	return fmt.Sprintf("[%s] %v", code, err)
}

func (m *manageClient) Ctrl(ctx context.Context, op string, args ...string) ([]byte, error) {
	resp, err := m.c.Ctrl(ctx, connect.NewRequest(&v1.CtrlRequest{Op: op, Args: args}))
	if err != nil {
		return nil, err
	}
	return resp.Msg.Result, nil
}

func (m *manageClient) UpsertRepo(ctx context.Context, ns, name string, isPrivate bool) error {
	_, err := m.c.UpsertRepo(ctx, connect.NewRequest(&v1.UpsertRepoRequest{Ns: ns, Name: name, IsPrivate: isPrivate}))
	return err
}

func (m *manageClient) CreateNS(ctx context.Context, ns string) error {
	_, err := m.c.CreateNS(ctx, connect.NewRequest(&v1.CreateNSRequest{Ns: ns}))
	return err
}

func (m *manageClient) DeleteNS(ctx context.Context, ns string) error {
	_, err := m.c.DeleteNS(ctx, connect.NewRequest(&v1.DeleteNSRequest{Ns: ns}))
	return err
}

func (m *manageClient) ExistRepo(ctx context.Context, ns, name string) (bool, error) {
	_, err := m.c.ExistRepo(ctx, connect.NewRequest(&v1.ExistRepoRequest{Ns: ns, Name: name}))
	if err != nil {
		if connect.CodeOf(err) == connect.CodeNotFound {
			return false, nil
		}
		return false, err
	}
	return true, nil
}

func (m *manageClient) DeleteRepo(ctx context.Context, ns, name string) error {
	_, err := m.c.DeleteRepo(ctx, connect.NewRequest(&v1.DeleteRepoRequest{Ns: ns, Name: name}))
	return err
}

func (m *manageClient) MoveRepo(ctx context.Context, src, dst string) error {
	_, err := m.c.MoveRepo(ctx, connect.NewRequest(&v1.MoveRepoRequest{Src: src, Dst: dst}))
	return err
}

func (m *manageClient) MoveNS(ctx context.Context, src, dst string) error {
	_, err := m.c.MoveNS(ctx, connect.NewRequest(&v1.MoveNSRequest{Src: src, Dst: dst}))
	return err
}

func (m *manageClient) UserPasswordUpsert(ctx context.Context, ns, password string) error {
	_, err := m.c.UserPasswordUpsert(ctx, connect.NewRequest(&v1.UserPasswordUpsertRequest{Ns: ns, Password: password}))
	return err
}

func (m *manageClient) UserDelete(ctx context.Context, ns string) error {
	_, err := m.c.UserDelete(ctx, connect.NewRequest(&v1.UserDeleteRequest{Ns: ns}))
	return err
}

func (m *manageClient) ACLUpsertSSHKeyOnNS(ctx context.Context, ns, key, perm string) (int64, error) {
	resp, err := m.c.ACLUpsertSSHKeyOnNS(ctx, connect.NewRequest(&v1.ACLUpsertSSHKeyOnNSRequest{Ns: ns, Key: key, Perm: perm}))
	if err != nil {
		return 0, err
	}
	return resp.Msg.AclId, nil
}

func (m *manageClient) ACLUpsertPATOnNS(ctx context.Context, ns, pat, perm string) (int64, error) {
	resp, err := m.c.ACLUpsertPATOnNS(ctx, connect.NewRequest(&v1.ACLUpsertPATOnNSRequest{Ns: ns, Pat: pat, Perm: perm}))
	if err != nil {
		return 0, err
	}
	return resp.Msg.AclId, nil
}

func (m *manageClient) ACLUpsertSSHKeyOnRepo(ctx context.Context, reponame, key, perm string) (int64, error) {
	resp, err := m.c.ACLUpsertSSHKeyOnRepo(ctx, connect.NewRequest(&v1.ACLUpsertSSHKeyOnRepoRequest{Reponame: reponame, Key: key, Perm: perm}))
	if err != nil {
		return 0, err
	}
	return resp.Msg.AclId, nil
}

func (m *manageClient) ACLUpsertPATOnRepo(ctx context.Context, reponame, pat, perm string) (int64, error) {
	resp, err := m.c.ACLUpsertPATOnRepo(ctx, connect.NewRequest(&v1.ACLUpsertPATOnRepoRequest{Reponame: reponame, Pat: pat, Perm: perm}))
	if err != nil {
		return 0, err
	}
	return resp.Msg.AclId, nil
}

func (m *manageClient) ACLDelete(ctx context.Context, id int64) error {
	_, err := m.c.ACLDelete(ctx, connect.NewRequest(&v1.ACLDeleteRequest{AclId: id}))
	return err
}

func (m *manageClient) ACLSetPerm(ctx context.Context, id int64, perm string) error {
	_, err := m.c.ACLSetPerm(ctx, connect.NewRequest(&v1.ACLSetPermRequest{AclId: id, Perm: perm}))
	return err
}

func (m *manageClient) Status(ctx context.Context) (*v1.StatusResponse, error) {
	resp, err := m.c.Status(ctx, connect.NewRequest(&emptypb.Empty{}))
	if err != nil {
		return nil, err
	}
	return resp.Msg, nil
}