package rpc

import (
	"context"
	"encoding/json"
	"time"

	"github.com/rs/zerolog/log"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	backend "github.com/woodpecker-ci/woodpecker/pipeline/backend/types"
	"github.com/woodpecker-ci/woodpecker/pipeline/rpc/proto"
)

var backoff = time.Second

type client struct {
	client proto.WoodpeckerClient
	conn   *grpc.ClientConn
}

// NewGrpcClient returns a new grpc Client.
func NewGrpcClient(conn *grpc.ClientConn) Peer {
	client := new(client)
	client.client = proto.NewWoodpeckerClient(conn)
	client.conn = conn
	return client
}

func (c *client) Close() error {
	return c.conn.Close()
}

// Next returns the next pipeline in the queue.
func (c *client) Next(ctx context.Context, f Filter) (*Pipeline, error) {
	var res *proto.NextReply
	var err error
	req := new(proto.NextRequest)
	req.Filter = new(proto.Filter)
	req.Filter.Expr = f.Expr
	req.Filter.Labels = f.Labels
	for {
		res, err = c.client.Next(ctx, req)
		if err == nil {
			break
		} else {
			log.Err(err).Msgf("grpc error: done(): code: %v: %s", status.Code(err), err)
		}
		switch status.Code(err) {
		case
			codes.Aborted,
			codes.DataLoss,
			codes.DeadlineExceeded,
			codes.Internal,
			codes.Unavailable:
			// non-fatal errors
		default:
			return nil, err
		}
		if ctx.Err() != nil {
			return nil, ctx.Err()
		}
		<-time.After(backoff)
	}

	if res.GetPipeline() == nil {
		return nil, nil
	}

	p := new(Pipeline)
	p.ID = res.GetPipeline().GetId()
	p.Timeout = res.GetPipeline().GetTimeout()
	p.Config = new(backend.Config)
	if err := json.Unmarshal(res.GetPipeline().GetPayload(), p.Config); err != nil {
		log.Error().Err(err).Msgf("could not unmarshal pipeline config of '%s'", p.ID)
	}
	return p, nil
}

// Wait blocks until the pipeline is complete.
func (c *client) Wait(ctx context.Context, id string) (err error) {
	req := new(proto.WaitRequest)
	req.Id = id
	for {
		_, err = c.client.Wait(ctx, req)
		if err == nil {
			break
		} else {
			log.Err(err).Msgf("grpc error: wait(): code: %v: %s", status.Code(err), err)
		}
		switch status.Code(err) {
		case
			codes.Aborted,
			codes.DataLoss,
			codes.DeadlineExceeded,
			codes.Internal,
			codes.Unavailable:
			// non-fatal errors
		default:
			return err
		}
		<-time.After(backoff)
	}
	return nil
}

// Init signals the pipeline is initialized.
func (c *client) Init(ctx context.Context, id string, state State) (err error) {
	req := new(proto.InitRequest)
	req.Id = id
	req.State = new(proto.State)
	req.State.Error = state.Error
	req.State.ExitCode = int32(state.ExitCode)
	req.State.Exited = state.Exited
	req.State.Finished = state.Finished
	req.State.Started = state.Started
	req.State.Name = state.Proc
	for {
		_, err = c.client.Init(ctx, req)
		if err == nil {
			break
		} else {
			log.Err(err).Msgf("grpc error: init(): code: %v: %s", status.Code(err), err)
		}
		switch status.Code(err) {
		case
			codes.Aborted,
			codes.DataLoss,
			codes.DeadlineExceeded,
			codes.Internal,
			codes.Unavailable:
			// non-fatal errors
		default:
			return err
		}
		<-time.After(backoff)
	}
	return nil
}

// Done signals the pipeline is complete.
func (c *client) Done(ctx context.Context, id string, state State) (err error) {
	req := new(proto.DoneRequest)
	req.Id = id
	req.State = new(proto.State)
	req.State.Error = state.Error
	req.State.ExitCode = int32(state.ExitCode)
	req.State.Exited = state.Exited
	req.State.Finished = state.Finished
	req.State.Started = state.Started
	req.State.Name = state.Proc
	for {
		_, err = c.client.Done(ctx, req)
		if err == nil {
			break
		} else {
			log.Err(err).Msgf("grpc error: done(): code: %v: %s", status.Code(err), err)
		}
		switch status.Code(err) {
		case
			codes.Aborted,
			codes.DataLoss,
			codes.DeadlineExceeded,
			codes.Internal,
			codes.Unavailable:
			// non-fatal errors
		default:
			return err
		}
		<-time.After(backoff)
	}
	return nil
}

// Extend extends the pipeline deadline
func (c *client) Extend(ctx context.Context, id string) (err error) {
	req := new(proto.ExtendRequest)
	req.Id = id
	for {
		_, err = c.client.Extend(ctx, req)
		if err == nil {
			break
		} else {
			log.Err(err).Msgf("grpc error: extend(): code: %v: %s", status.Code(err), err)
		}
		switch status.Code(err) {
		case
			codes.Aborted,
			codes.DataLoss,
			codes.DeadlineExceeded,
			codes.Internal,
			codes.Unavailable:
			// non-fatal errors
		default:
			return err
		}
		<-time.After(backoff)
	}
	return nil
}

// Update updates the pipeline state.
func (c *client) Update(ctx context.Context, id string, state State) (err error) {
	req := new(proto.UpdateRequest)
	req.Id = id
	req.State = new(proto.State)
	req.State.Error = state.Error
	req.State.ExitCode = int32(state.ExitCode)
	req.State.Exited = state.Exited
	req.State.Finished = state.Finished
	req.State.Started = state.Started
	req.State.Name = state.Proc
	for {
		_, err = c.client.Update(ctx, req)
		if err == nil {
			break
		} else {
			log.Err(err).Msgf("grpc error: update(): code: %v: %s", status.Code(err), err)
		}
		switch status.Code(err) {
		case
			codes.Aborted,
			codes.DataLoss,
			codes.DeadlineExceeded,
			codes.Internal,
			codes.Unavailable:
			// non-fatal errors
		default:
			return err
		}
		<-time.After(backoff)
	}
	return nil
}

// Upload uploads the pipeline artifact.
func (c *client) Upload(ctx context.Context, id string, file *File) (err error) {
	req := new(proto.UploadRequest)
	req.Id = id
	req.File = new(proto.File)
	req.File.Name = file.Name
	req.File.Mime = file.Mime
	req.File.Proc = file.Proc
	req.File.Size = int32(file.Size)
	req.File.Time = file.Time
	req.File.Data = file.Data
	req.File.Meta = file.Meta
	for {
		_, err = c.client.Upload(ctx, req)
		if err == nil {
			break
		} else {
			log.Err(err).Msgf("grpc error: upload(): code: %v: %s", status.Code(err), err)
		}
		switch status.Code(err) {
		case
			codes.Aborted,
			codes.DataLoss,
			codes.DeadlineExceeded,
			codes.Internal,
			codes.Unavailable:
			// non-fatal errors
		default:
			return err
		}
		<-time.After(backoff)
	}
	return nil
}

// Log writes the pipeline log entry.
func (c *client) Log(ctx context.Context, id string, line *Line) (err error) {
	req := new(proto.LogRequest)
	req.Id = id
	req.Line = new(proto.Line)
	req.Line.Out = line.Out
	req.Line.Pos = int32(line.Pos)
	req.Line.Proc = line.Proc
	req.Line.Time = line.Time
	for {
		_, err = c.client.Log(ctx, req)
		if err == nil {
			break
		} else {
			log.Err(err).Msgf("grpc error: log(): code: %v: %s", status.Code(err), err)
		}
		switch status.Code(err) {
		case
			codes.Aborted,
			codes.DataLoss,
			codes.DeadlineExceeded,
			codes.Internal,
			codes.Unavailable:
			// non-fatal errors
		default:
			return err
		}
		<-time.After(backoff)
	}
	return nil
}