package chain

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log/slog"
	"net/http"
	"time"

	"github.com/emochka2007/block-accounting/internal/infrastructure/ethapi"
	"github.com/emochka2007/block-accounting/internal/infrastructure/repository/transactions"
	"github.com/emochka2007/block-accounting/internal/pkg/config"
	"github.com/emochka2007/block-accounting/internal/pkg/ctxmeta"
	"github.com/emochka2007/block-accounting/internal/pkg/logger"
	"github.com/emochka2007/block-accounting/internal/pkg/models"
	"github.com/emochka2007/block-accounting/internal/usecase/interactors/organizations"
	"github.com/ethereum/go-ethereum/common"
	"github.com/google/uuid"
)

type ChainInteractor interface {
	PubKey(ctx context.Context, user *models.User) ([]byte, error)

	NewMultisig(ctx context.Context, params NewMultisigParams) error
	ListMultisigs(ctx context.Context, params ListMultisigsParams) ([]models.Multisig, error)

	PayrollDeploy(ctx context.Context, params PayrollDeployParams) error
	ListPayrolls(ctx context.Context, params ListPayrollsParams) ([]models.Payroll, error)
	SetSalary(ctx context.Context, params SetSalaryParams) error
}

type chainInteractor struct {
	log                     *slog.Logger
	config                  config.Config
	txRepository            transactions.Repository
	organizationsInteractor organizations.OrganizationsInteractor
	client                  ethapi.EthAPIClient
}

func NewChainInteractor(
	log *slog.Logger,
	config config.Config,
	txRepository transactions.Repository,
	organizationsInteractor organizations.OrganizationsInteractor,
	client ethapi.EthAPIClient,
) ChainInteractor {
	return &chainInteractor{
		log:                     log,
		config:                  config,
		txRepository:            txRepository,
		organizationsInteractor: organizationsInteractor,
	}
}

type NewMultisigParams struct {
	Title         string
	Owners        []models.OrganizationParticipant
	Confirmations int
}

func (i *chainInteractor) NewMultisig(ctx context.Context, params NewMultisigParams) error {
	endpoint := i.config.ChainAPI.Host + "/multi-sig/deploy"

	i.log.Debug(
		"deploy multisig",
		slog.String("endpoint", endpoint),
		slog.Any("params", params),
	)

	pks := make([]string, len(params.Owners))

	for i, owner := range params.Owners {
		if owner.GetUser() == nil {
			return fmt.Errorf("error invalis owners set")
		}

		pks[i] = "0x" + common.Bytes2Hex(owner.GetUser().PublicKey())
	}

	user, err := ctxmeta.User(ctx)
	if err != nil {
		return fmt.Errorf("error fetch user from context. %w", err)
	}

	organizationID, err := ctxmeta.OrganizationId(ctx)
	if err != nil {
		return fmt.Errorf("error fetch organization id from context. %w", err)
	}

	go func() { // TODO remove this subroutine shit and replace it with worker queue tasks
		pid := uuid.Must(uuid.NewV7()).String()
		startTime := time.Now()

		i.log.Info(
			"new multisig worker started",
			slog.String("pid", pid),
		)

		doneCh := make(chan struct{}, 1)

		defer func() {
			if err := recover(); err != nil {
				i.log.Error("worker paniced!", slog.Any("panic", err))
			}

			doneCh <- struct{}{}
			close(doneCh)
		}()

		go func() {
			warn := time.After(1 * time.Minute)
			select {
			case <-doneCh:
				i.log.Info(
					"new multisig worker done",
					slog.String("pid", pid),
					slog.Time("started at", startTime),
					slog.Time("done at", time.Now()),
					slog.Duration("work time", time.Since(startTime)),
				)
			case <-warn:
				i.log.Warn(
					"new multisig worker seems sleeping",
					slog.String("pid", pid),
					slog.Duration("work time", time.Since(startTime)),
				)
			}
		}()

		requestContext, cancel := context.WithTimeout(context.TODO(), time.Minute*15)
		defer cancel()

		requestContext = ctxmeta.UserContext(requestContext, user)

		address, err := i.client.DeployMultisig(requestContext, pks, params.Confirmations)
		if err != nil {
			i.log.Error(
				"error send deploy multisig request",
				slog.String("endpoint", endpoint),
				slog.Any("params", params),
			)

			return
		}

		multisigAddress := common.Hex2Bytes(address[2:])

		createdAt := time.Now()

		msg := models.Multisig{
			ID:                    uuid.Must(uuid.NewV7()),
			Title:                 params.Title,
			Address:               multisigAddress,
			OrganizationID:        organizationID,
			Owners:                params.Owners,
			ConfirmationsRequired: params.Confirmations,
			CreatedAt:             createdAt,
			UpdatedAt:             createdAt,
		}

		if err := i.txRepository.AddMultisig(requestContext, msg); err != nil {
			i.log.Error(
				"error add new multisig",
				logger.Err(err),
			)

			return
		}
	}()

	return nil
}

func (i *chainInteractor) PubKey(ctx context.Context, user *models.User) ([]byte, error) {
	pubAddr := i.config.ChainAPI.Host + "/address-from-seed"

	requestBody, err := json.Marshal(map[string]any{
		"seedPhrase": user.Mnemonic,
	})
	if err != nil {
		return nil, fmt.Errorf("error marshal request body. %w", err)
	}

	body := bytes.NewBuffer(requestBody)

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, pubAddr, body)
	if err != nil {
		return nil, fmt.Errorf("error build request. %w", err)
	}

	req.Header.Add("X-Seed", common.Bytes2Hex(user.Seed()))
	req.Header.Add("Content-Type", "application/json")

	// TODO replace http.DefaultClient with custom ChainAPi client from infrastructure/ethapi mod
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("error fetch pub address. %w", err)
	}

	defer resp.Body.Close()

	respBody, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("error read resp body. %w", err)
	}

	pubKeyStr := string(respBody)[2:]

	if pubKeyStr == "" {
		return nil, fmt.Errorf("error empty public key...")
	}

	return common.Hex2Bytes(pubKeyStr), nil
}

type PayrollDeployParams struct {
	FirstAdmin models.OrganizationParticipant
	MultisigID uuid.UUID
	Title      string
}

type newPayrollContractChainResponse struct {
	Address string `json:"address"`
}

func (i *chainInteractor) PayrollDeploy(
	ctx context.Context,
	params PayrollDeployParams,
) error {
	user, err := ctxmeta.User(ctx)
	if err != nil {
		return fmt.Errorf("error fetch user from context. %w", err)
	}

	if user.Id() != params.FirstAdmin.Id() || params.FirstAdmin.GetUser() == nil {
		return fmt.Errorf("error unauthorized access")
	}

	organizationID, err := ctxmeta.OrganizationId(ctx)
	if err != nil {
		return fmt.Errorf("error fetch organization id from context. %w", err)
	}

	multisigs, err := i.ListMultisigs(ctx, ListMultisigsParams{
		OrganizationID: organizationID,
		IDs:            uuid.UUIDs{params.MultisigID},
	})
	if err != nil {
		return fmt.Errorf("error fetch multisigs by id. %w", err)
	}

	if len(multisigs) == 0 {
		return fmt.Errorf("error empty multisigs set")
	}

	i.log.Debug(
		"PayrollDeploy",
		slog.String("organization id", organizationID.String()),
		slog.String("multisig id", params.MultisigID.String()),
		slog.String("multisig address", common.Bytes2Hex(multisigs[0].Address)),
		slog.String("X-Seed header data", common.Bytes2Hex(user.Seed())),
	)

	maddr := common.Bytes2Hex(multisigs[0].Address)

	if maddr == "" {
		return fmt.Errorf("empty multisig address")
	}

	if maddr[0] != 0 && maddr[1] != 'x' {
		maddr = "0x" + maddr
	}

	requestBody, err := json.Marshal(map[string]any{
		"authorizedWallet": maddr,
	})
	if err != nil {
		return fmt.Errorf("error marshal request body. %w", err)
	}

	go func() { // TODO remove this subroutine shit and replace it with worker pools
		pid := uuid.Must(uuid.NewV7()).String()
		startTime := time.Now()

		i.log.Info(
			"new paroll worker started",
			slog.String("pid", pid),
		)

		doneCh := make(chan struct{}, 1)

		defer func() {
			if err := recover(); err != nil {
				i.log.Error("worker paniced!", slog.Any("panic", err))
			}

			doneCh <- struct{}{}
			close(doneCh)
		}()

		go func() {
			warn := time.After(2 * time.Minute)
			select {
			case <-doneCh:
				i.log.Info(
					"new payroll worker done",
					slog.String("pid", pid),
					slog.Time("started at", startTime),
					slog.Time("done at", time.Now()),
					slog.Duration("work time", time.Since(startTime)),
				)
			case <-warn:
				i.log.Warn(
					"new paroll worker seems sleeping",
					slog.String("pid", pid),
					slog.Duration("work time", time.Since(startTime)),
				)
			}
		}()

		requestContext, cancel := context.WithTimeout(context.TODO(), time.Minute*20)
		defer cancel()

		body := bytes.NewBuffer(requestBody)

		endpoint := i.config.ChainAPI.Host + "/salaries/deploy"

		i.log.Debug(
			"request",
			slog.String("body", string(requestBody)),
			slog.String("endpoint", endpoint),
		)

		req, err := http.NewRequestWithContext(requestContext, http.MethodPost, endpoint, body)
		if err != nil {
			i.log.Error(
				"error build request",
				logger.Err(fmt.Errorf("error build request. %w", err)),
			)
			return
		}

		req.Header.Add("Content-Type", "application/json")
		req.Header.Add("X-Seed", common.Bytes2Hex(user.Seed()))

		// TODO replace http.DefaultClient with custom ChainAPi client from infrastructure/ethapi mod
		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			i.log.Error(
				"error fetch deploy salary contract",
				logger.Err(err),
			)

			return
		}

		defer resp.Body.Close()

		raw, err := io.ReadAll(resp.Body)
		if err != nil {
			i.log.Error(
				"error read body",
				logger.Err(err),
			)

			return
		}

		respObject := new(newPayrollContractChainResponse)

		if err := json.Unmarshal(raw, &respObject); err != nil {
			i.log.Error(
				"error parse chain-api response body",
				logger.Err(err),
			)

			return
		}

		i.log.Debug(
			"payroll deploy",
			slog.Any("response", respObject),
		)

		if respObject.Address == "" {
			i.log.Error(
				"error multisig address is empty",
			)

			return
		}

		addr := common.Hex2Bytes(respObject.Address[2:])

		createdAt := time.Now()

		if err := i.txRepository.AddPayrollContract(requestContext, transactions.AddPayrollContract{
			ID:             uuid.Must(uuid.NewV7()),
			Title:          params.Title,
			Address:        addr,
			OrganizationID: organizationID,
			MultisigID:     params.MultisigID,
			CreatedAt:      createdAt,
		}); err != nil {
			i.log.Error(
				"error add new payroll contract",
				logger.Err(err),
			)

			return
		}
	}()

	return nil
}

type ListMultisigsParams struct {
	IDs            uuid.UUIDs
	OrganizationID uuid.UUID
}

func (i *chainInteractor) ListMultisigs(
	ctx context.Context,
	params ListMultisigsParams,
) ([]models.Multisig, error) {
	multisigs, err := i.txRepository.ListMultisig(ctx, transactions.ListMultisigsParams{
		IDs:            params.IDs,
		OrganizationID: params.OrganizationID,
	})
	if err != nil {
		return nil, fmt.Errorf("error fetch multisigs. %w", err)
	}

	return multisigs, nil
}

type ListPayrollsParams struct {
	IDs            []uuid.UUID
	Limit          int
	OrganizationID uuid.UUID
}

func (i *chainInteractor) ListPayrolls(
	ctx context.Context,
	params ListPayrollsParams,
) ([]models.Payroll, error) {
	payrolls, err := i.txRepository.ListPayrolls(ctx, transactions.ListPayrollsParams{
		IDs:            params.IDs,
		Limit:          int64(params.Limit),
		OrganizationID: params.OrganizationID,
	})
	if err != nil {
		return nil, fmt.Errorf("error fetch payrolls from repository. %w", err)
	}

	return payrolls, nil
}

type SetSalaryParams struct {
	PayrollID  uuid.UUID
	EmployeeID uuid.UUID
	Salary     float64
}

func (i *chainInteractor) SetSalary(
	ctx context.Context,
	params SetSalaryParams,
) error {
	user, err := ctxmeta.User(ctx)
	if err != nil {
		return fmt.Errorf("error fetch user from context. %w", err)
	}

	organizationID, err := ctxmeta.OrganizationId(ctx)
	if err != nil {
		return fmt.Errorf("error fetch organization id from context. %w", err)
	}

	i.log.Debug(
		"SetSalary",
		slog.String("org id", organizationID.String()),
		slog.Any("user", user),
	)

	payrolls, err := i.ListPayrolls(ctx, ListPayrollsParams{
		IDs:            []uuid.UUID{params.PayrollID},
		OrganizationID: organizationID,
	})
	if err != nil {
		return fmt.Errorf("error fetch payroll. %w", err)
	}

	if len(payrolls) == 0 {
		return fmt.Errorf("error payroll not found. %w", err)
	}

	payroll := payrolls[0]

	multisigs, err := i.ListMultisigs(ctx, ListMultisigsParams{
		IDs:            uuid.UUIDs{payroll.MultisigID},
		OrganizationID: organizationID,
	})
	if err != nil {
		return fmt.Errorf("error fetch multisig. %w", err)
	}

	if len(multisigs) == 0 {
		return fmt.Errorf("error multisig not found. %w", err)
	}

	multisig := multisigs[0]

	employee, err := i.organizationsInteractor.Participant(ctx, organizations.ParticipantParams{
		ID:             params.EmployeeID,
		OrganizationID: organizationID,
		EmployeesOnly:  true,
	})
	if err != nil {
		return fmt.Errorf("error fetch employee from repository. %w", err)
	}

	if employee.GetEmployee() == nil {
		return fmt.Errorf("error employee is nil")
	}

	go func() {
		defer func() {
			if err := recover(); err != nil {
				i.log.Error("worker paniced!", slog.Any("panic", err))
			}

			// doneCh <- struct{}{}
			// close(doneCh)
		}()

		ctx, cancel := context.WithTimeout(context.TODO(), 2*time.Minute)
		defer cancel()

		maddr := common.Bytes2Hex(multisig.Address)
		if maddr[0] != 0 && maddr[1] != 'x' {
			maddr = "0x" + maddr
		}

		caddr := common.Bytes2Hex(payroll.Address)
		if caddr[0] != 0 && caddr[1] != 'x' {
			caddr = "0x" + caddr
		}

		eaddr := common.Bytes2Hex(employee.GetEmployee().WalletAddress)
		if caddr[0] != 0 && caddr[1] != 'x' {
			caddr = "0x" + caddr
		}

		bodyMap := map[string]any{
			"multiSigWallet":  maddr,
			"contractAddress": caddr,
			"employeeAddress": eaddr,
			"salary":          params.Salary,
		}

		bodyRaw, err := json.Marshal(&bodyMap)
		if err != nil {
			i.log.Error(
				"error marshal request body",
				logger.Err(err),
			)

			return
		}

		req, err := http.NewRequestWithContext(
			ctx,
			http.MethodPost,
			i.config.ChainAPI.Host+"/salaries/set-salary",
			bytes.NewBuffer(bodyRaw),
		)
		if err != nil {
			i.log.Error(
				"error build request",
				logger.Err(err),
			)

			return
		}

		req.Header.Add("Content-Type", "application/json")
		req.Header.Add("X-Seed", common.Bytes2Hex(user.Seed()))

		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			i.log.Error(
				"error do request",
				logger.Err(err),
			)

			return
		}

		defer resp.Body.Close()

		// todo parse body
	}()

	return nil
}