package repository

import (
	"context"
	"fmt"

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



func NewMarketSettingStore(s *Store) ports.MarketSettingStore { return s }

func (s *Store) InsertGlobalMarketSettings(ctx context.Context, setting domain.CreateGlobalMarketSettings) error {
	err := s.queries.InsertGlobalMarketSettings(ctx, domain.ConvertCreateGlobalMarketSettings(setting))
	if err != nil {
		return err
	}
	return nil
}

func (s *Store) InsertCompanyMarketSettings(ctx context.Context, setting domain.CreateCompanyMarketSettings) error {
	err := s.queries.InsertCompanyMarketSettings(ctx, domain.ConvertCreateCompanyMarketSettings(setting))
	if err != nil {
		return err
	}
	return nil
}

func (s *Store) GetAllGlobalMarketSettings(ctx context.Context, filter domain.MarketSettingFilter) ([]domain.MarketSettings, error) {
	settings, err := s.queries.GetAllGlobalMarketSettings(ctx, dbgen.GetAllGlobalMarketSettingsParams{
		Offset: pgtype.Int4{
			Int32: int32(filter.Offset.Value * filter.Limit.Value),
			Valid: filter.Offset.Valid,
		},
		Limit:  filter.Limit.ToPG(),
	})
	if err != nil {
		return nil, err
	}

	return domain.ConvertDBGlobalMarketSettingsList(settings), nil
}

func (s *Store) GetGlobalMarketSettingsByID(ctx context.Context, Id int64) (domain.MarketSettings, error) {
	setting, err := s.queries.GetGlobalMarketSettingsByID(ctx, Id)
	if err != nil {
		return domain.MarketSettings{}, err
	}

	return domain.ConvertDBGlobalMarketSettings(setting), nil
}

func (s *Store) GetAllCompanyMarketSettings(ctx context.Context, filter domain.CompanyMarketSettingFilter) ([]domain.CompanyMarketSettings, error) {
	settings, err := s.queries.GetAllCompanyMarketSettings(ctx, dbgen.GetAllCompanyMarketSettingsParams{
		Offset: pgtype.Int4{
			Int32: int32(filter.Offset.Value * filter.Limit.Value),
			Valid: filter.Offset.Valid,
		},
		Limit:     filter.Limit.ToPG(),
		CompanyID: filter.CompanyID.ToPG(),
	})
	if err != nil {
		return nil, err
	}

	return domain.ConvertDBCompanyMarketSettingsList(settings), nil
}

func (s *Store) GetCompanyMarketSettings(ctx context.Context, ID int64) (domain.CompanyMarketSettings, error) {
	setting, err := s.queries.GetCompanyMarketSettingsByID(ctx, ID)
	if err != nil {
		return domain.CompanyMarketSettings{}, err
	}

	return domain.ConvertDBCompanyMarketSettings(setting), nil
}

func (s *Store) GetAllOverrideMarketSettings(ctx context.Context, companyID int64, filter domain.MarketSettingFilter) ([]domain.MarketSettings, error) {
	settings, err := s.queries.GetAllOverrideMarketSettings(ctx, dbgen.GetAllOverrideMarketSettingsParams{
		CompanyID: companyID,
		Offset: pgtype.Int4{
			Int32: int32(filter.Offset.Value * filter.Limit.Value),
			Valid: filter.Offset.Valid,
		},
		Limit:     filter.Limit.ToPG(),
	})
	if err != nil {
		return nil, err
	}

	return domain.ConvertDBGetAllOverrideMarketSettingsList(settings), nil
}

func (s *Store) GetOverrideMarketSettingByID(ctx context.Context, companyID int64, marketID int64) (domain.MarketSettings, error) {
	setting, err := s.queries.GetOverrideMarketSettingByID(ctx, dbgen.GetOverrideMarketSettingByIDParams{
		CompanyID: companyID,
		MarketID:  marketID,
	})

	if err != nil {
		return domain.MarketSettings{}, nil
	}

	return domain.ConvertDBGetOverrideMarketSettingsByID(setting), nil
}

func (s *Store) DeleteAllCompanyMarketSettings(ctx context.Context, companyID int64) error {
	err := s.queries.DeleteAllMarketSettingsForCompany(ctx, companyID)
	if err != nil {
		return err
	}
	return nil
}

func (s *Store) DeleteCompanyMarketSettings(ctx context.Context, companyID int64, marketID int64) error {
	err := s.queries.DeleteCompanyMarketSettings(ctx, dbgen.DeleteCompanyMarketSettingsParams{
		MarketID:  marketID,
		CompanyID: companyID,
	})
	if err != nil {
		return err
	}
	return nil
}

func (s *Store) EnsureAllMarketSettingsExist(ctx context.Context) error {
	dbMarketSettings, err := s.GetAllGlobalMarketSettings(ctx, domain.MarketSettingFilter{})
	if err != nil {
		return fmt.Errorf("failed to fetch global market settings: %w", err)
	}

	dbCompanies, err := s.GetAllCompanies(ctx, domain.CompanyFilter{})
	if err != nil {
		return fmt.Errorf("failed to fetch companies: %w", err)
	}
	existing := map[int64]struct{}{}
	for _, s := range dbMarketSettings {
		existing[s.MarketID] = struct{}{}
	}

	for id, defaultIsActive := range domain.SupportedMarkets {
		if _, found := existing[id]; !found {
			name, err := domain.GetMarketName(id)
			if err != nil {
				return err
			}
			err = s.InsertGlobalMarketSettings(ctx, domain.CreateGlobalMarketSettings{
				MarketID: id,
				MarketName: name,
				IsActive: defaultIsActive,
			})
			if  err != nil{
				return fmt.Errorf("failed to insert market %d (%s): %w", id, name, err)
			}
		}

		// This is to auto disabled markets that haven't been tested yet
		for _, company := range dbCompanies {
			if company.Slug == "fortunebets" {
				continue
			}

			if _, found := domain.DisabledMarkets[id]; !found {
				continue
			} 
			name, err := domain.GetMarketName(id)
			err = s.InsertCompanyMarketSettings(ctx, domain.CreateCompanyMarketSettings{
				CompanyID: company.ID,
				MarketID: id,
				MarketName: name,
				IsActive: domain.ValidBool{
					Value: false,
					Valid: true,
				},
			})
			if err != nil {
				return fmt.Errorf("failed to insert company market %d (%s): %w", id, name, err)
			}
		}
	}
	return nil

}