<?php

namespace App\Filament\Pages;

use App\Actions\LoadSofaScoreCategory;
use App\Actions\LoadStatisticFixturesLeaguesOptions;
use App\Actions\LoadStatisticFixturesMatchOptions;
use App\Filament\Widgets\PlayerPropsDrop;
use App\Filament\Widgets\PlayerPropsTable;
use App\Models\SofaScoreRosa;
use App\Models\SsLineupMemory;
use App\Models\StatisticFixtures;
use BackedEnum;
use Filament\Actions\Action;
use Filament\Forms\Components\DatePicker;
use Filament\Forms\Components\Radio;
use Filament\Forms\Components\Select;
use Filament\Forms\Concerns\InteractsWithForms;
use Filament\Forms\Contracts\HasForms;
use Filament\Navigation\NavigationItem;
use Filament\Pages\Page;
use Filament\Schemas\Components\Utilities\Get;
use Filament\Schemas\Components\Utilities\Set;
use Filament\Schemas\Schema;
use Illuminate\Support\Facades\Auth;
use Livewire\Attributes\On;

class PlayerProps extends Page implements HasForms
{
    use InteractsWithForms;

    protected string $view = 'filament.pages.player-props';

    public static function getNavigationItems(): array
    {
        return [
            NavigationItem::make(static::getNavigationLabel())
                ->group(static::getNavigationGroup())
                ->icon(static::getNavigationIcon())
                ->activeIcon(static::getActiveNavigationIcon())
                ->isActiveWhen(fn () => request()->routeIs(static::getRouteName()))
                ->sort(static::getNavigationSort())
                ->url(static::getUrl(), shouldOpenInNewTab: true), // 👈 Forces target="_blank"
        ];
    }

    protected static string|BackedEnum|null $navigationIcon = 'icon-soccerplayer';

    public function getHeading(): string
    {
        return '';
    }

    protected static ?string $title = 'Player Props';

    protected static ?int $navigationSort = 2;

    public ?array $filterData;

    public array $lineUpOptions;

    public string $activeLineUp = '3313';

    public array $players = [];

    public array $clientLineUps = [];

    public int $team_id;

    public function mount(): void
    {
        // Initialisiert das Formular mit leeren Werten
        $this->form->fill();
    }

    public function getWidgetData(): array
    {
        return [
            'activeLineUp' => $this->activeLineUp,
        ];
    }

    public function form(Schema $schema): Schema
    {
        return $schema
            ->columns(5)
            ->components([
                $this->selectCountry(),
                $this->selectLeague(),
                $this->selectMatch(),
                $this->selectTeam(),
                $this->selectLineup(),
                // $this->radioSeasonOrDate(),
                // $this->datePickerStartDate(),
                // $this->datePickerEndDate(),
            ])->statePath('filterData');
    }

    #[On('team-update')]
    public function syncData(?int $team_id)
    {
        if ($team_id) {
            $this->team_id = $team_id;
            $this->clientLineUps = SsLineupMemory::where('team_id', $team_id)->where('client_id', Auth::user()->client_id)->pluck('lineup')->toArray();
        } else {
            $this->players = [];
            $this->dispatch('clear-all');
        }
    }

    #[On('update-players')]
    public function updatePlayers(array $players)
    {
        $this->players = $players;
    }

    #[On('update-lineup')]
    public function updateLineup(string $lineup_name)
    {
        $this->filterData['lineup'] = $lineup_name;
    }

    protected function getFooterWidgets(): array
    {
        return [
            PlayerPropsTable::make(['players' => $this->players]),
            PlayerPropsDrop::make(['players' => $this->players]),
        ];
    }

    public function getFooterWidgetsColumns(): int|array
    {
        return 5;
    }

    private function lineUpOptions(): array
    {
        return [
            '3313' => '3313',
            '3331' => '3331',
            '3331-' => '3331-',
            '3331+' => '3331+',
            '3412-' => '3412-',
            '3412+' => '3412+',
            '3421-' => '3421-',
            '3421+' => '3421+',
            '343-' => '343-',
            '343+' => '343+',
            '3511' => '3511',
            '3511-' => '3511-',
            '3511+' => '3511+',
            '352' => '352',
            '352-' => '352-',
            '352+' => '352+',
            '4132' => '4132',
            '4213-' => '4213-',
            '4213+' => '4213+',
            '4222' => '4222',
            '4231' => '4231',
            '424' => '424',
            '4312' => '4312',
            '4312-' => '4312-',
            '4312+' => '4312+',
            '4321' => '4321',
            '4321-' => '4321-',
            '4321+' => '4321+',
            '433' => '433',
            '433-' => '433-',
            '433+' => '433+',
            '4411-' => '4411-',
            '4411+' => '4411+',
            '442' => '442',
            '442-' => '442-',
            '442+' => '442+',
            '451' => '451',
            '451-' => '451-',
            '451+' => '451+',
            '523-' => '523-',
            '523+' => '523+',
            '5311' => '5311',
            '5311-' => '5311-',
            '5311+' => '5311+',
            '532' => '532',
            '532-' => '532-',
            '532+' => '532+',
            '541-' => '541-',
            '541+' => '541+',
        ];
    }

    private function selectTeam(): Select
    {
        return Select::make('tid')
            ->live()
            ->hiddenLabel()
            ->prefixIconColor(fn (Get $get): string => $get('tid') ? 'success' : 'danger')
            ->prefixIcon('icon-player')
            ->options(function (Get $get) {
                if ($get('mid')) {
                    $res = StatisticFixtures::where('id', $get('mid'))->first();

                    $arr = [];
                    if ($res) {
                        $arr[$res->home_id] = SofaScoreRosa::query()->where('ss_team_id', $res->home_id)->value('ss_team_name');
                        $arr[$res->away_id] = SofaScoreRosa::query()->where('ss_team_id', $res->away_id)->value('ss_team_name');
                    }

                    return $arr;
                }
            })
            ->placeholder('Team')
            ->afterStateUpdated(function ($state, Set $set) {
                if ($state) {
                    $this->dispatch('team-update', team_id: $state);
                    $tmp = SsLineupMemory::where('client_id', Auth::user()->client_id)->where('team_id', $state)->orderBy('created_at', 'desc')->first();
                    if ($tmp) {
                        $set('lineup', $tmp->lineup);
                        $this->dispatch('lineup-update', activeLineUp: $tmp->lineup);
                    }
                }
            });
    }

    private function selectLeague(): Select
    {
        return Select::make('lid')
            ->live()
            ->preload()
            ->prefixIconColor(fn (Get $get): string => $get('lid') ? 'success' : 'danger')
            ->prefixIcon('phosphor-trophy-fill')
            ->hiddenLabel()
            ->options(fn (Get $get) => LoadStatisticFixturesLeaguesOptions::load($get('cid')))
            ->placeholder('League')
            ->afterStateUpdated(function (callable $set) {
                $set('mid', null);
                $set('tid', null);
                $this->dispatch('clear-all');
            });
    }

    private function selectMatch(): Select
    {
        return Select::make('mid')
            ->live()
            ->hiddenLabel()
            ->prefixIconColor(fn (Get $get): string => $get('mid') ? 'success' : 'danger')
            ->prefixIcon('phosphor-calendar-check-fill')
            ->options(function (Get $get) {
                return LoadStatisticFixturesMatchOptions::load($get('lid'));
            })
            ->afterStateUpdated(function (callable $set, $state) {
                $set('tid', null);
                if ($state) {
                    $this->dispatch('match-update', match_id: $state);
                } else {
                    $this->dispatch('clear-all');
                }
            })
            ->placeholder('Events');
    }

    private function selectLineup(): Select
    {
        return Select::make('lineup')
            ->live()
            ->hiddenLabel()
            ->allowHtml()
            ->native(false)
            ->selectablePlaceholder(false)
            ->prefixIconColor('info')
            ->prefixIcon('icon-soccerfield-fill')
            ->options(function () {
                $res = $this->lineUpOptions();
                $arr = [];
                foreach ($res as $key => $value) {
                    $arr[$key] = $value;
                }

                return $arr;
            })
            ->placeholder('LineUp')
            ->searchable()
            ->default($this->activeLineUp)
            ->afterStateUpdated(function ($state) {
                $this->dispatch('lineup-update', activeLineUp: $state);
            });
    }

    private function selectCountry(): Select
    {
        return Select::make('cid')
            ->live()
            ->preload()
            ->searchable(false)
            ->prefixIconColor(fn (Get $get): string => $get('cid') ? 'success' : 'danger')
            ->prefixIcon('phosphor-globe-fill')
            ->hiddenLabel()
            ->options(fn () => LoadSofaScoreCategory::load())
            ->placeholder('Country')
            ->afterStateUpdated(function (callable $set, $state) {
                $set('lid', null);
                $set('mid', null);
                $set('tid', null);
                $this->dispatch('clear-all');
            });
    }

    private function radioSeasonOrDate(): Radio
    {
        return Radio::make('season_or_date')
            ->live()
            ->extraAttributes([
                'class' => 'radio-statistic-group',
            ])
            ->columnSpan(2)
            ->inline()
            ->default('season')
            ->hiddenLabel()
            ->options([
                'season' => 'Season',
                'date' => 'Date',
            ]);
    }

    private function datePickerStartDate(): DatePicker
    {
        return DatePicker::make('start_date')
            ->live()
            ->hiddenLabel()
            ->hidden(fn (Get $get) => $get('season_or_date') == 'season')
            ->native(false)
            ->prefixIconColor(fn (Get $get): string => $get('start_date') ? 'success' : 'primary')
            ->prefixIcon('phosphor-calendar')
            ->prefix('Start')
            ->suffixAction(
                Action::make('clear_start')
                    ->icon('phosphor-x')
                    ->color('gray')
                    ->action(fn (Set $set) => $set('start_date', null))
            );
    }

    private function datePickerEndDate(): DatePicker
    {
        return DatePicker::make('end_date')
            ->live()
            ->hiddenLabel()
            ->hidden(fn (Get $get) => $get('season_or_date') == 'season')
            ->native(false)
            ->prefixIconColor(fn (Get $get): string => $get('end_date') ? 'success' : 'primary')
            ->prefixIcon('phosphor-calendar')
            ->prefix('End')
            ->suffixAction(
                Action::make('clear_end')
                    ->icon('phosphor-x')
                    ->color('gray')
                    ->action(fn (Set $set) => $set('end_date', null))
            );
    }
}