package domain

import (
	"encoding/json"
	"time"

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

type CreateOddMarket struct {
	EventID        string
	MarketCategory string
	MarketType     string
	MarketName     string
	MarketID       string
	UpdatedAt      time.Time
	Odds           []map[string]interface{}
}

type OddMarket struct {
	ID              int64             `json:"id"`
	EventID         string            `json:"event_id"`
	MarketType      string            `json:"market_type"`
	MarketName      string            `json:"market_name"`
	MarketCategory  string            `json:"market_category"`
	MarketID        string            `json:"market_id"`
	RawOdds         []json.RawMessage `json:"raw_odds"`
	FetchedAt       time.Time         `json:"fetched_at"`
	ExpiresAt       time.Time         `json:"expires_at"`
	DefaultIsActive bool              `json:"is_active"`
	IsMonitored     bool              `json:"is_monitored"`
	IsLive          bool              `json:"is_live"`
	Status          EventStatus       `json:"status"`
	Source          EventSource       `json:"source"`
}
type OddMarketWithSettings struct {
	ID             int64             `json:"id"`
	EventID        string            `json:"event_id"`
	MarketType     string            `json:"market_type"`
	MarketName     string            `json:"market_name"`
	MarketCategory string            `json:"market_category"`
	MarketID       string            `json:"market_id"`
	RawOdds        []json.RawMessage `json:"raw_odds"`
	FetchedAt      time.Time         `json:"fetched_at"`
	ExpiresAt      time.Time         `json:"expires_at"`
	IsActive       bool              `json:"is_active"`
}

type OddMarketSettings struct {
	CompanyID     int64
	OddMarketID   int64
	IsActive      ValidBool
	CustomRawOdds string
	UpdatedAt     time.Time
}
type CreateOddMarketSettings struct {
	CompanyID     int64
	OddMarketID   int64
	IsActive      ValidBool
	CustomRawOdds []map[string]interface{}
}

type CustomOdd struct {
	OddID    int64   `json:"odd_id"`
	OddValue float32 `json:"odd_value"`
}

type CreateOddMarketSettingsReq struct {
	OddMarketID int64       `json:"odd_market_id"`
	IsActive    *bool       `json:"is_active,omitempty"`
	CustomOdd   []CustomOdd `json:"custom_odd,omitempty"`
}

type RawOddsByMarketID struct {
	ID         int64                    `json:"id"`
	MarketName string                   `json:"market_name"`
	Handicap   string                   `json:"handicap"`
	RawOdds    []map[string]interface{} `json:"raw_odds"`
	FetchedAt  time.Time                `json:"fetched_at"`
	ExpiresAt  time.Time                `json:"expires_at"`
}

type OddMarketFilter struct {
	Limit  ValidInt32
	Offset ValidInt32
}
type OddMarketWithEventFilter struct {
	Limit  ValidInt32
	Offset ValidInt32
}

func ConvertDBOddMarket(oddMarket dbgen.OddsMarketWithEvent) (OddMarket, error) {
	var rawOdds []json.RawMessage
	if len(oddMarket.RawOdds) > 0 {
		if err := json.Unmarshal(oddMarket.RawOdds, &rawOdds); err != nil {
			return OddMarket{}, err
		}
	} else {
		rawOdds = []json.RawMessage{} // explicit empty slice
	}
	return OddMarket{
		ID:              oddMarket.ID,
		EventID:         oddMarket.EventID,
		MarketType:      oddMarket.MarketType,
		MarketName:      oddMarket.MarketName,
		MarketCategory:  oddMarket.MarketCategory,
		MarketID:        oddMarket.MarketID,
		RawOdds:         rawOdds,
		FetchedAt:       oddMarket.FetchedAt.Time,
		ExpiresAt:       oddMarket.ExpiresAt.Time,
		DefaultIsActive: oddMarket.DefaultIsActive,
		IsMonitored:     oddMarket.IsMonitored,
		IsLive:          oddMarket.IsLive,
		Status:          EventStatus(oddMarket.Status),
		Source:          EventSource(oddMarket.Source),
	}, nil
}

func ConvertDBOddMarkets(oddMarkets []dbgen.OddsMarketWithEvent) ([]OddMarket, error) {
	result := make([]OddMarket, len(oddMarkets))
	for i, om := range oddMarkets {
		convertedMarket, err := ConvertDBOddMarket(om)
		if err != nil {
			return nil, err
		}
		result[i] = convertedMarket
	}
	return result, nil
}

func ConvertCreateOddMarket(oddMarket CreateOddMarket) (dbgen.InsertOddsMarketParams, error) {
	rawOddsBytes, err := json.Marshal(oddMarket.Odds)
	if err != nil {
		return dbgen.InsertOddsMarketParams{}, err
	}

	return dbgen.InsertOddsMarketParams{
		EventID:        oddMarket.EventID,
		MarketType:     oddMarket.MarketType,
		MarketName:     oddMarket.MarketName,
		MarketCategory: oddMarket.MarketCategory,
		MarketID:       oddMarket.MarketID,
		RawOdds:        rawOddsBytes,
		FetchedAt:      pgtype.Timestamp{Time: time.Now(), Valid: true},
		ExpiresAt:      pgtype.Timestamp{Time: (time.Now()).Add(time.Hour), Valid: true},
	}, nil
}

func ConvertCreateOddMarketSetting(oms CreateOddMarketSettings) (dbgen.SaveOddSettingsParams, error) {
	rawOddsBytes, err := json.Marshal(oms.CustomRawOdds)
	if err != nil {
		return dbgen.SaveOddSettingsParams{}, err
	}
	return dbgen.SaveOddSettingsParams{
		CompanyID:     oms.CompanyID,
		OddsMarketID:  oms.OddMarketID,
		IsActive:      oms.IsActive.ToPG(),
		CustomRawOdds: rawOddsBytes,
	}, nil
}

func ConvertDBOddMarketWithSetting(oms dbgen.OddsMarketWithSetting) (OddMarketWithSettings, error) {
	var rawOdds []json.RawMessage
	if len(oms.RawOdds) > 0 {
		if err := json.Unmarshal(oms.RawOdds, &rawOdds); err != nil {
			return OddMarketWithSettings{}, err
		}
	} else {
		rawOdds = []json.RawMessage{} // explicit empty slice
	}
	return OddMarketWithSettings{
		ID:             oms.ID,
		EventID:        oms.EventID,
		MarketType:     oms.MarketType,
		MarketName:     oms.MarketName,
		MarketCategory: oms.MarketCategory,
		MarketID:       oms.MarketID,
		RawOdds:        rawOdds,
		FetchedAt:      oms.FetchedAt.Time,
		ExpiresAt:      oms.ExpiresAt.Time,
		IsActive:       oms.IsActive,
	}, nil
}

func ConvertDBOddMarketWithSettings(oms []dbgen.OddsMarketWithSetting) ([]OddMarketWithSettings, error) {
	result := make([]OddMarketWithSettings, len(oms))
	for i, o := range oms {
		converted, err := ConvertDBOddMarketWithSetting(o)
		if err != nil {
			return nil, err
		}
		result[i] = converted
	}

	return result, nil
}