<?php

namespace App\Carriers\Filament\Resources;

use App\Bookings\Services\BookingService;
use App\Carriers\Filament\Resources\CarrierPreferredLaneResource\RelationManagers\PreferredLanesRelationManager;
use App\Carriers\Filament\Resources\CarrierResource\Pages;
use App\Carriers\Filament\Resources\CarrierResource\RelationManagers\AvailableTrucksRelationManager;
use App\Carriers\Filament\Resources\CarrierResource\RelationManagers\BookingsRelationManager;
use App\Carriers\Filament\Resources\CarrierResource\RelationManagers\ContactsRelationManager;
use App\Carriers\Filament\Resources\CarrierResource\RelationManagers\CarrierTasksRelationManager;
use App\Carriers\Filament\Resources\CarrierResource\RelationManagers\CarrierActivitiesRelationManager;
use App\Carriers\Models\ClientCarrier;
use App\Carriers\Services\AvailableTruckService;
use App\Carriers\Services\PreferredLaneService;
use App\Clients\Enums\ClientTypeValue;
use App\Clients\Models\Client;
use App\User\Models\User;
use Carbon\Carbon;
use Cheesegrits\FilamentGoogleMaps\Fields\Geocomplete;
use Filament\Facades\Filament;
use Filament\Forms\Components\Actions\Action;
use Filament\Forms\Components\Grid;
use Filament\Forms\Components\Section;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\Textarea;
use Filament\Forms\Components\TextInput;
use Filament\Forms\Form;
use Filament\Forms\Get;
use Filament\Infolists\Components\TextEntry;
use Filament\Infolists\Infolist;
use Filament\Resources\Resource;
use Filament\Tables\Actions\ViewAction;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Enums\FiltersLayout;
use Filament\Tables\Filters\Filter;
use Filament\Tables\Filters\SelectFilter;
use Filament\Tables\Table;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;

class CarrierResource extends Resource
{
    protected static ?string $model = ClientCarrier::class;

    public static ?string $label = 'Carrier';

    protected static ?string $navigationIcon = 'heroicon-s-truck';

    protected static ?int $navigationSort = 5;

    public static function isScopedToTenant(): bool
    {
        return !User::getCurrentTenant()->types->pluck('type')->contains(ClientTypeValue::ADMIN->value);
    }

    public static function infolist(Infolist $infolist): Infolist
    {
        return $infolist->schema([
            \Filament\Infolists\Components\Section::make('Information')->schema([
                TextEntry::make('legal_name')
                    ->state(function ($record) {
                        if (!empty($record->legal_name)) {
                            return $record->legal_name;
                        }
                        return $record->name;
                    })
                    ->label('Name'),

                TextEntry::make('mc_number')
                    ->label('MC Number'),

                TextEntry::make('dot_number')
                    ->label('DOT Number'),

                TextEntry::make('email')
                    ->label('Email'),

                TextEntry::make('address_line_1')
                    ->label('Street Address'),

                TextEntry::make('city')
                    ->label('City'),

                TextEntry::make('state')
                    ->label('State'),

                TextEntry::make('postal_code')
                    ->label('Postal Code'),
            ])->columns(4),

            \Filament\Infolists\Components\Section::make('Insurance')->schema([
                TextEntry::make('cargo_insurance_expires_at')
                    ->badge()
                    ->color(function ($state) {
                        if (!empty($state)) {
                            return Carbon::parse($state)->isPast() ? 'warning' : 'success';
                        }
                        return '';
                    })
                    ->label('Cargo Insurance Expiry Date'),

                TextEntry::make('cargo_insurance_amount')
                    ->formatStateUsing(function ($record) {
                        return sprintf('$%s', number_format($record->cargo_insurance_amount / 100));
                    }),

                TextEntry::make('liability_insurance_expires_at')
                    ->badge()
                    ->label('Liability Insurance Expiry Date')
                    ->color(function ($state) {
                        if (!empty($state)) {
                            return Carbon::parse($state)->isPast() ? 'warning' : 'success';
                        }
                        return '';
                    }),

                TextEntry::make('liability_insurance_amount')->label('Liability Insurance Amount')
                ->formatStateUsing(function ($record) {
                    return sprintf('$%s', number_format($record->liability_insurance_amount / 100));
                }),

                TextEntry::make('auto_insurance_expires_at')->label('Auto Insurance Expiry Date')
                    ->badge()
                    ->color(function ($state) {
                        if (!empty($state)) {
                            return Carbon::parse($state)->isPast() ? 'warning' : 'success';
                        }
                        return '';
                    }),

                TextEntry::make('auto_insurance_amount')->label('Auto Insurance Amount')
                ->formatStateUsing(function ($record) {
                    return sprintf('$%s', number_format($record->auto_insurance_amount / 100));
                }),
            ])->columns(6),
        ]);
    }

    public static function form(Form $form): Form
    {
        return $form
            ->schema([
                Section::make('Company Information')
                    ->schema([])
                    ->columns(4)
                    ->headerActions([
                        Action::make('Contact Carrier')
                            ->icon('heroicon-o-envelope')
                            ->form([
                                Select::make('method')
                                    ->live()
                                    ->options([
                                        'email' => 'Email',
                                        'sms' => 'Text Message',
                                        'phone' => 'Phone',
                                    ]),
                                Grid::make('email')
                                    ->schema(function (Get $get): array {
                                        return match ($get('method')) {
                                            'email' => [
                                                TextInput::make('subject')
                                                    ->label('Subject')
                                                    ->placeholder('Subject')
                                                    ->required(),
                                                Textarea::make('message')
                                                    ->label('Message')
                                                    ->placeholder('Message')
                                                    ->required(),
                                            ],
                                            'sms' => [
                                                Textarea::make('message')
                                                    ->label('Message')
                                                    ->placeholder('Message')
                                                    ->maxLength(160 * 3),
                                            ],
                                            'phone' => [
                                                TextInput::make('phone_number')
                                                    ->label('Your Phone Number')
                                                    ->tel()
                                                    ->mask('(999) 999-9999')
                                                    ->hint('Enter your phone number to be connected to the carrier.')
                                                    ->placeholder('Phone Number')
                                                    ->required(),
                                            ],
                                            default => [],
                                        };
                                    }),
                            ])
                            ->modal()
                            ->modalSubmitActionLabel('Contact Carrier'),
                    ]),
            ]);
    }

    public static function table(Table $table): Table
    {
        return $table
            ->paginated([50])
            ->searchable(false)
            ->columns([
                TextColumn::make('client.name')
                    ->label('Client')
                    ->visible(fn() => auth()->user() instanceof User)
                    ->visible(!static::isScopedToTenant()),

                TextColumn::make('name')
                    ->label('Company Name')
                    ->searchable()
                    ->sortable(),

                TextColumn::make('dot_number')
                    ->label('DOT Number'),

                TextColumn::make('mc_number')
                    ->label('MC Number'),

                TextColumn::make('carrier.power_units')
                    ->label('Trucks')
                    ->sortable()
                    ->getStateUsing(function (ClientCarrier $clientCarrier) {
                        if ($clientCarrier->carrier->is_imported === true && $clientCarrier->carrier->power_units > 0) {
                            return [
                                'Power Units x ' . $clientCarrier->carrier->power_units,
                            ];
                        }
                        return 'N/A';
                    })
                    ->listWithLineBreaks()
                    ->width('10%'),

                TextColumn::make('active')
                    ->label('Status')
                    ->badge()
                    ->getStateUsing(function (ClientCarrier $clientCarrier) {
                        return $clientCarrier->active ? 'Active' : 'Inactive';
                    })
                    ->color(function (ClientCarrier $clientCarrier) {
                        return $clientCarrier->active ? 'success' : 'info';
                    }),

                TextColumn::make('bookings_count')->label('Bookings')->sortable(),
            ])
            ->filters([
                SelectFilter::make('client_id')->label('Client')
                    ->multiple()
                    ->options(Client::all()->pluck('name', 'id'))
                    ->visible(!static::isScopedToTenant()),

                Filter::make('keyword')
                    ->indicateUsing(function (array $data) {
                        if (empty($data['keyword'])) {
                            return;
                        }
                        return 'Search Term: ' . $data['keyword'];
                    })
                    ->form([
                        TextInput::make('keyword')->label('Name, MC Number, or DOT Number')->live(debounce: 500),
                    ])
                    ->query(function (Builder $query, array $data) {
                        if (!empty($data['keyword'])) {
                            $query->where(function (Builder $query) use ($data) {
                                $query->where('name', 'ILIKE', '%' . $data['keyword'] . '%')
                                    ->orWhere('legal_name', 'ILIKE', '%' . $data['keyword'] . '%');
                            });

                            if (Str::of($data['keyword'])->isMatch('/[0-9]/')) {
                                $query->orWhereHas('carrier', function (Builder $query) use ($data) {
                                    $query->where('mc_number', 'ILIKE', $data['keyword'] . '%')
                                        ->orWhere('dot_number', 'ILIKE', $data['keyword'] . '%');
                                });
                            }

                            return $query;
                        }
                    }),

                SelectFilter::make('client')
                    ->options(function () {
                        return Client::has('carriers')->get()->pluck('name', 'id');
                    })
                    ->preload()
                    ->multiple()
                    ->placeholder('Choose Client')
                    ->label('Client')
                    ->modifyQueryUsing(function (Builder $query, array $data): Builder {
                        if (!empty($data['values']) && count($data['values']) > 0) {
                            return $query->whereIn('client_id', $data['values']);
                        }

                        return $query;
                    })
                    ->visible(User::getCurrentTenant()->types()->where('type', ClientTypeValue::ADMIN)->exists()),

                Filter::make('equipment')
                    ->form([
                        Select::make('equipment_minimum')
                            ->multiple()
                            ->label('Truck Count')
                            ->options([
                                1   => '1-4',
                                2   =>  '5-19',
                                3   =>  '20-499',
                                4   =>  '500+',
                            ]),
                    ])
                    ->modifyQueryUsing(function (Builder $query, array $data): Builder {
                        if (!empty($data['equipment_type']) && count($data['equipment_type']) > 0) {
                            $query->whereHas('equipment', function (Builder $query) use ($data) {
                                $query->whereIn('equipment_id', $data['equipment_type']);
                            });
                        }
                        if ($data['equipment_minimum'] != null && $data['equipment_minimum'] > 0) {
                            $minimumTrucks = null;
                            $maximumTrucks = null;
                            foreach ($data['equipment_minimum'] as $value) {
                                $match = match ((int) $value) {
                                    1 => [1, 4],
                                    2 => [5, 19],
                                    3 => [20, 499],
                                    default => [500, 10000000],
                                };
                                if ($minimumTrucks == null || $match[0] < $minimumTrucks) {
                                    $minimumTrucks = $match[0];
                                }

                                if ($maximumTrucks == null || $match[1] > $maximumTrucks) {
                                    $maximumTrucks = $match[1];
                                }
                            }

                            if ($minimumTrucks === null || $maximumTrucks === null) {
                                return $query;
                            }

                            $query->whereHas('carrier', function (Builder $query) use ($minimumTrucks, $maximumTrucks) {
                                $query->where(function (Builder $query) use ($minimumTrucks) {
                                    $query->where('total_trailers', '>=', $minimumTrucks)
                                    ->where('power_units', '>=', $minimumTrucks);
                                });

                                if ($maximumTrucks) {
                                    $query->where(function (Builder $query) use ($maximumTrucks) {
                                        $query->where('total_trailers', '<=', $maximumTrucks)
                                            ->where('power_units', '<=', $maximumTrucks);
                                    });
                                }
                            });
                        }

                        return $query;
                    }),

                Filter::make('origin')->form([
                    Geocomplete::make('origin')
                        ->filterName('origin')
                        ->countries(['US'])
                        ->reverseGeocode([
                            'city' => '%L',
                            'state' => '%a1',
                        ])
                        ->label('Origin'),

                    Geocomplete::make('destination')
                        ->filterName('Destination')
                        ->countries(['US'])
                        ->reverseGeocode([
                            'city' => '%L',
                            'state' => '%a1',
                        ])
                        ->label('Destination'),
                ])->query(function (Builder $query, array $data) {
                    if (empty($data['destination']) && empty($data['origin'])) {
                        return $query;
                    }

                    $exploded = explode(', ', $data['destination']);
                    $destination_city = $exploded[0] ?? null;
                    $destination_state = $exploded[1] ?? null;

                    $exploded = explode(', ', $data['origin']);
                    $origin_city = $exploded[0] ?? null;
                    $origin_state = $exploded[1] ?? null;

                    $available_trucks = AvailableTruckService::getAvailableTrucksByOriginAndDestination(
                        $origin_city,
                        $origin_state,
                    );

                    if (count($available_trucks)) {
                        $query->whereIn('client_carriers.carrier_id', $available_trucks->pluck('carrier_id')->toArray());
                    }

                    $preferred_lanes = PreferredLaneService::getPreferredLanesByOriginAndDestination(
                        $origin_city,
                        $origin_state,
                        $destination_city,
                        $destination_state,
                    );

                    if (count($preferred_lanes)) {
                        $query->whereIn('client_carriers.carrier_id', $preferred_lanes->pluck('carrier_id')->toArray());
                    }

                    $client = Filament::getTenant();

                    $historic_bookings = BookingService::getHistoricBookingsByCarrierByCityAndStateOriginAndDestination(
                        $client,
                        $origin_city,
                        $origin_state,
                        $destination_city,
                        $destination_state,
                    );

                    if (count($historic_bookings)) {
                        $query->whereIn('client_carriers.carrier_id', $historic_bookings->pluck('carrier_id')->toArray());
                    }
                })->columnSpan(2)->columns(2),
            ], layout: FiltersLayout::AboveContent)
            ->modifyQueryUsing(function (Builder $query) {
                $tenant = Filament::getTenant();

                $query->leftJoin(DB::raw(
                    "(SELECT
                        bookings.carrier_id,
                        count(bookings.id) as bookings_count
                    FROM
                        newtrul.bookings
                        INNER JOIN newtrul.loads ON loads.id = bookings.load_id
                    WHERE
                        bookings.client_id = {$tenant->id}
                        and loads.deleted_at is null and bookings.deleted_at is null
                        AND loads.client_id = {$tenant->id}
                        group by 1) as bookings",
                ), 'bookings.carrier_id', '=', 'client_carriers.carrier_id')

                ->select([
                    'client_carriers.*',
                    DB::raw('CASE WHEN bookings.bookings_count IS NULL THEN 0 ELSE bookings.bookings_count END as bookings_count'),
                ])
                ->groupBy('client_carriers.id', 'bookings.bookings_count');

                return $query;
            })
            ->defaultSort('name')
            ->persistSortInSession()
            ->actions([
                ViewAction::make(),
            ])
            ->emptyStateActions([])
            ->bulkActions([])
            ->headerActions([])
            ->filtersFormColumns(4)
            ->emptyStateActions([])
            ->bulkActions([]);
    }

    public static function getRelations(): array
    {
        return [
            PreferredLanesRelationManager::class,
            AvailableTrucksRelationManager::class,
            ContactsRelationManager::class,
            BookingsRelationManager::class,
            CarrierTasksRelationManager::class,
            CarrierActivitiesRelationManager::class,
        ];
    }

    public static function getPages(): array
    {
        return [
            'index' => Pages\ListCarriers::route('/'),
            'view' => Pages\ViewCarrier::route('/{record}'),
            'tasks' => CarrierTaskResource\Pages\CarrierTasksPage::route('/tasks'),
            'activities' => CarrierActivityResource\Pages\CarrierActivitiesPage::route('/activities'),
        ];
    }
}