package repository

import (
	"context"
	"encoding/json"

	"os"
	"strconv"
	"time"

	dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
	"github.com/jackc/pgx/v5/pgtype"
)

func (s *Store) SaveOddMarket(ctx context.Context, m domain.CreateOddMarket) error {
	if len(m.Odds) == 0 {
		return nil
	}

	params, err := domain.ConvertCreateOddMarket(m)

	if err != nil {
		return err
	}

	err = s.queries.InsertOddsMarket(ctx, params)
	if err != nil {
		_ = writeFailedMarketLog(m, err)
		return err
	}
	return nil
}

func writeFailedMarketLog(m domain.CreateOddMarket, err error) error {
	logDir := "logs"
	logFile := logDir + "/failed_markets.log"

	if mkErr := os.MkdirAll(logDir, 0755); mkErr != nil {
		return mkErr
	}

	f, fileErr := os.OpenFile(logFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if fileErr != nil {
		return fileErr
	}
	defer f.Close()

	entry := struct {
		Time   string                 `json:"time"`
		Error  string                 `json:"error"`
		Record domain.CreateOddMarket `json:"record"`
	}{
		Time:   time.Now().Format(time.RFC3339),
		Error:  err.Error(),
		Record: m,
	}

	jsonData, _ := json.MarshalIndent(entry, "", "  ")
	_, writeErr := f.WriteString(string(jsonData) + "\n\n")
	return writeErr
}

func (s *Store) GetAllOdds(ctx context.Context, filter domain.OddMarketFilter) ([]domain.OddMarket, error) {
	rows, err := s.queries.GetAllOdds(ctx, dbgen.GetAllOddsParams{
		Offset: filter.Offset.ToPG(),
		Limit:  filter.Limit.ToPG(),
	})
	if err != nil {
		return nil, err
	}

	domainOdds, err := domain.ConvertDBOddMarkets(rows)

	if err != nil {
		return nil, err
	}

	return domainOdds, nil
}

func (s *Store) GetAllOddsWithSettings(ctx context.Context, companyID int64, filter domain.OddMarketFilter) ([]domain.OddMarketWithSettings, error) {
	odds, err := s.queries.GetAllOddsWithSettings(ctx, dbgen.GetAllOddsWithSettingsParams{
		CompanyID: companyID,
		Offset:    filter.Offset.ToPG(),
		Limit:     filter.Limit.ToPG(),
	})
	if err != nil {
		return nil, err
	}

	domainOdds, err := domain.ConvertDBOddMarketWithSettings(odds)

	if err != nil {
		return nil, err
	}

	return domainOdds, nil
}

func (s *Store) GetOddsByMarketID(ctx context.Context, marketID string, eventID string) (domain.OddMarket, error) {

	odds, err := s.queries.GetOddsByMarketID(ctx, dbgen.GetOddsByMarketIDParams{
		MarketID: marketID,
		EventID:  eventID,
	})
	if err != nil {
		return domain.OddMarket{}, err
	}

	convertedOdd, err := domain.ConvertDBOddMarket(odds)

	if err != nil {
		return domain.OddMarket{}, err
	}
	return convertedOdd, nil
}

func (s *Store) GetOddsWithSettingsByMarketID(ctx context.Context, marketID string, eventID string, companyID int64) (domain.OddMarketWithSettings, error) {

	odds, err := s.queries.GetOddsWithSettingsByMarketID(ctx, dbgen.GetOddsWithSettingsByMarketIDParams{
		MarketID:  marketID,
		EventID:   eventID,
		CompanyID: companyID,
	})
	if err != nil {
		return domain.OddMarketWithSettings{}, err
	}

	convertedOdd, err := domain.ConvertDBOddMarketWithSetting(odds)

	if err != nil {
		return domain.OddMarketWithSettings{}, err
	}
	return convertedOdd, nil
}

func (s *Store) GetOddsByEventID(ctx context.Context, upcomingID string, filter domain.OddMarketWithEventFilter) ([]domain.OddMarket, error) {
	odds, err := s.queries.GetOddsByEventID(ctx, dbgen.GetOddsByEventIDParams{
		EventID: upcomingID,
		Limit:   filter.Limit.ToPG(),
		Offset:  filter.Offset.ToPG(),
		IsLive: pgtype.Bool{
			Bool:  false,
			Valid: true,
		},
		Status: pgtype.Text{
			String: string(domain.STATUS_PENDING),
			Valid:  true,
		},
		Source: pgtype.Text{},
	})
	if err != nil {
		return nil, err
	}
	// Map the results to domain.Odd
	domainOdds, err := domain.ConvertDBOddMarkets(odds)
	if err != nil {
		return nil, err
	}

	return domainOdds, nil
}

func (s *Store) GetOddsWithSettingsByEventID(ctx context.Context, upcomingID string, companyID int64, filter domain.OddMarketFilter) ([]domain.OddMarketWithSettings, error) {

	odds, err := s.queries.GetOddsWithSettingsByEventID(ctx, dbgen.GetOddsWithSettingsByEventIDParams{
		EventID:   upcomingID,
		CompanyID: companyID,
		Offset:    filter.Offset.ToPG(),
		Limit:     filter.Limit.ToPG(),
	})
	if err != nil {
		return nil, err
	}

	// Map the results to domain.Odd
	domainOdds, err := domain.ConvertDBOddMarketWithSettings(odds)
	if err != nil {
		return nil, err
	}

	return domainOdds, nil
}

func (s *Store) DeleteOddsForEvent(ctx context.Context, eventID string) error {
	return s.queries.DeleteOddsForEvent(ctx, eventID)
}

func getString(v interface{}) string {
	if s, ok := v.(string); ok {
		return s
	}
	return ""
}

func getConvertedFloat(v interface{}) float64 {
	if s, ok := v.(string); ok {
		f, err := strconv.ParseFloat(s, 64)
		if err == nil {
			return f
		}
	}
	return 0
}

func getFloat(v interface{}) float64 {
	if n, ok := v.(float64); ok {
		return n
	}
	return 0
}

func getMap(v interface{}) map[string]interface{} {
	if m, ok := v.(map[string]interface{}); ok {
		return m
	}
	return nil
}