package app

import (
	"bytes"
	"cake_crm/internal/modules/messenger"
	"cake_crm/internal/modules/storage"
	"cake_crm/internal/services/card"
	proto "cake_crm/proto"
	"context"
	"errors"
	"fmt"
)

type Server struct {
	proto.UnsafeCRMServer
	storage     storage.IStorage
	messenger   messenger.IMessenger
	cardService *card.Service
}

func NewServer(storage storage.IStorage, messenger messenger.IMessenger, cardService *card.Service) proto.CRMServer {
	return &Server{
		storage:     storage,
		messenger:   messenger,
		cardService: cardService,
	}
}

func (s *Server) GetCatalog(ctx context.Context, _ *proto.GetCatalogReq) (*proto.CatalogRsp, error) {
	categories, err := s.storage.GetCatalog(ctx)
	if err != nil {
		return nil, err
	}
	return &proto.CatalogRsp{Categories: categories}, nil
}

func (s *Server) GetPositions(ctx context.Context, req *proto.GetPositionsReq) (*proto.PositionsRsp, error) {
	products, err := s.storage.GetPositions(ctx, req.Id)
	if err != nil {
		return nil, err
	}
	return &proto.PositionsRsp{Products: products}, nil
}

func (s *Server) GetProduct(ctx context.Context, req *proto.GetProductReq) (*proto.ProductRsp, error) {
	product, err := s.storage.GetProduct(ctx, req.Id)
	if err != nil {
		return nil, err
	}
	return &proto.ProductRsp{Product: product}, nil
}

func (s *Server) GetBreadcrumbs(ctx context.Context, req *proto.GetBreadcrumbsReq) (*proto.BreadcrumbsRsp, error) {
	breadcrumbs, err := s.storage.GetBreadcrumbs(ctx, req.Id)
	if err != nil {
		return nil, err
	}
	return &proto.BreadcrumbsRsp{Categories: breadcrumbs}, nil
}

func (s *Server) Order(ctx context.Context, req *proto.OrderReq) (*proto.OrderRsp, error) {
	enrichItems, err := s.cardService.GetCard(ctx, req.Order.Items)
	if err != nil {
		return nil, err
	}
	text, err := createOrderText(req, enrichItems)
	if err != nil {
		return nil, err
	}
	return &proto.OrderRsp{}, s.messenger.SendMessage(text)
}

func createOrderText(req *proto.OrderReq, items []*proto.CardItem) (string, error) {
	buffer := bytes.Buffer{}
	var orderAmount int64
	buffer.WriteString(fmt.Sprintf("Заказ от:\n%s\n%s\n", req.Name, req.Phone))
	buffer.WriteString("\n")
	for _, item := range items {
		buffer.WriteString(item.Name)
		buffer.WriteString("\n")
		unit, err := unitToText(item.Unit)
		if err != nil {
			return "", err
		}
		buffer.WriteString(fmt.Sprintf("Количество: %d%s\n", item.Count, unit))
		orderAmount += item.Amount
		buffer.WriteString(fmt.Sprintf("Сумма: %.00fр\n", float64(item.Amount)/100))
		buffer.WriteString("\n")
	}
	buffer.WriteString("\n")
	buffer.WriteString(fmt.Sprintf("ИТОГО: %.00fр\n", float64(orderAmount)/100))
	return buffer.String(), nil
}

func unitToText(unit string) (string, error) {
	switch unit {
	case "kg":
		return "кг", nil
	case "piece":
		return "шт", nil
	}
	return "", errors.New("unit not found")
}

func (s *Server) GetCard(ctx context.Context, req *proto.CardReq) (*proto.CardRsp, error) {
	enrichItems, err := s.cardService.GetCard(ctx, req.Items)
	if err != nil {
		return nil, err
	}
	return &proto.CardRsp{Items: enrichItems}, nil
}