<?php

namespace App\Http\Controllers\Frontend;

use App\Facades\AccountsService;
use App\Facades\CompanyProfilesService;
use App\Http\Controllers\Controller;
use App\Http\Requests\AccountAddressUpdateRequest;
use App\Http\Requests\AccountMemberInviteRequest;
use App\Http\Requests\AccountMemberAdminStatus;
use App\Http\Requests\AccountProfileUpdateRequest;
use App\Http\Requests\AccountRequest;
use App\Http\Requests\AccountProfileSocialsUpdateRequest;
use App\Http\Requests\AccountUploadRequest;
use App\Http\Requests\BasicListingRequest;
use App\Http\Requests\BillingAddressRequest;
use App\Http\Resources\AccountProfile\AccountInvoiceResource;
use App\Http\Resources\AccountProfile\AccountProfileAddressResource;
use App\Http\Resources\AccountProfile\AccountProfileResultEntityResource;
use App\Http\Resources\AccountProfileResultWinnerResource;
use App\Http\Resources\Subscriptions\AccountResource;
use App\Http\Resources\AccountProfile\AccountProfileResource;
use App\Http\Resources\BasicSelectResource;
use App\Http\Resources\Subscriptions\MemberResource;
use App\Models\AccountMember;
use App\Models\CompanySpecialisation;
use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class AccountsController extends Controller
{
    public function show()
    {
        // TODO: Implement show method
    }

    public function create(AccountRequest $request)
    {
        $data = $request->validated();
        $user = Auth::user();

        $account = AccountsService::create($user, $data);

        return new AccountResource($account);
    }

    public function updateAccountRegister(AccountRequest $request)
    {
        $data = $request->validated();
        $user = Auth::user();

        $account = AccountsService::updateAccountRegister($user, $data);

        return new AccountResource($account);
    }

    public function createBillingAddress(BillingAddressRequest $request)
    {
        $data = $request->validated();
        $user = Auth::user();

        $account = AccountsService::createUpdateAccountBillingAddress($user, $data);

        return new AccountResource($account);
    }

    public function inviteMember(AccountMemberInviteRequest $request)
    {
        $data = $request->validated();
        $user = Auth::user();

        $member = AccountsService::inviteMember($user, $data);

        return response()->json(['success' => $member != null]);
    }

    public function checkInvitation(string $token)
    {
        $member = AccountMember::where('token', $token)->first();
        $user = Auth::user();

        if (!$member) {
            return [
                'status' => 'not_found',
                'message' => trans('frontend.invitation_not_found')
            ];
        }

        if ($user && $user->email !== $member->invitation_email) {
            return [
                'status' => 'logged_user_email_mismatch',
                'message' => trans('frontend.invitation_email_mismatch')
            ];
        }

        if ($member->status !== AccountMember::STATUS_PENDING) {
            return [
                'status' => 'invitation_already_accepted',
                'message' => trans('frontend.invitation_already_accepted')
            ];
        }

        if ($user) {
            $member = AccountsService::acceptInvitation($user, $token);
            return [
                'status' => 'invitation_accepted',
                'message' => trans('frontend.invitation_accepted'),
            ];
        }

        $existingUser = User::where('email', $member->invitation_email)->first();

        return [
            'status' => 'invitation_found',
            'email' => $member->invitation_email,
            'firstName' => $member->invitation_first_name,
            'lastName' => $member->invitation_last_name,
            'userExists' => $existingUser != null
        ];
    }

    public function acceptInvitation(String $token)
    {
        $user = Auth::user();

        $member = AccountsService::acceptInvitation($user, $token);

        return response()->json(['success' => $member != null]);
    }

    public function getMembers(BasicListingRequest $request)
    {
        $user = Auth::user();

        $data = $request->validated();

        $members = AccountsService::getMembers($user, $data);

        return MemberResource::collection($members);
    }

    public function deleteMember($memberId)
    {
        $user = Auth::user();

        $member = AccountsService::deleteMember($user, $memberId);

        return response()->json(['success' => $member != null]);
    }

    public function updateMember(AccountMemberAdminStatus $request, $id)
    {
        $data = $request->validated();
        $user = Auth::user();

        $member = AccountsService::updateMember($user, $data, $id);

        return new MemberResource($member);
    }

    public function destroy($id)
    {
        // TODO: Implement destroy method
    }

    public function updateAccount(AccountProfileUpdateRequest $request)
    {
        $data = $request->validated();
        $user = Auth::user();

        $profile = CompanyProfilesService::updateProfile($user, $data);

        return new AccountProfileResource($profile);
    }

    public function updateAccountSocials(AccountProfileSocialsUpdateRequest $request)
    {
        $data = $request->validated();
        $user = Auth::user();

        $profile = CompanyProfilesService::updateSocials($user, $data);

        return new AccountProfileResource($profile);
    }

    public function updateAccountAddress(AccountAddressUpdateRequest $request)
    {
        $data = $request->validated();
        $user = Auth::user();

        $accountAddress = AccountsService::createUpdateAccountAddress($user, $data);

        return new AccountProfileAddressResource($accountAddress);
    }

    public function uploadCompanyImage(AccountUploadRequest $request)
    {
        $data = $request->validated();
        $image = $data['image'] ?? null;
        $user = Auth::user();

        $success = CompanyProfilesService::uploadCompanyImage($user, $image);
        return [
            'success' => $success
        ];
    }

    public function getCompanySpecialisations()
    {
        return BasicSelectResource::collection(CompanySpecialisation::full()->get());
    }

    public function getAccountResultWinners()
    {
        $user = Auth::user();

        $accountResultWinners = AccountsService::getAccountResultWinners($user);

        return AccountProfileResultWinnerResource::collection($accountResultWinners);
    }

    public function getAccountResultEntities()
    {
        $user = Auth::user();

        $accountResultEntities = AccountsService::getAccountResultEntities($user);

        return AccountProfileResultEntityResource::collection($accountResultEntities);
    }

    public function getInvoices(BasicListingRequest $request)
    {
        $user = Auth::user();
        $data = $request->validated();

        $invoices = AccountsService::getInvoices($user, $data);

        return AccountInvoiceResource::collection($invoices);
    }

    public function downloadInvoice($id)
    {
        $user = Auth::user();

        return AccountsService::downloadInvoice($user, $id);
    }
}