<?php

namespace Modules\Api\Http\Controllers;

use Illuminate\Routing\Controller;
use Modules\Api\Http\Controllers\Base\CrudApiController;
use Modules\Platform\User\Entities\User;
use Modules\Api\Http\Requests\GroupApiRequest;
use Modules\Contacts\Entities\Contact;
use Modules\Contacts\Entities\ContactSource;
use Modules\Contacts\Entities\ContactStatus;
use Modules\Platform\User\Repositories\RoleRepository;
use Modules\Platform\User\Repositories\UserRepository;
use Modules\Platform\User\Http\Requests\UserCreateRequest;
use Modules\Platform\User\Http\Requests\UserUpdateRequest;
use Modules\Platform\User\Service\UserService;
use Symfony\Component\Process\Process;
use Modules\Platform\Core\Helper\CompanySettings;
use Modules\Platform\Core\Helper\SettingsHelper;
use Torzer\Awesome\Landlord\Facades\Landlord;
use Modules\Platform\User\Entities\Group;
use Modules\Platform\User\Http\Forms\GroupForm;
use Modules\Platform\User\Http\Requests\GroupCreateRequest;
use Modules\Platform\User\Http\Requests\GroupUpdateRequest;
use Modules\Platform\User\Repositories\GroupRepository;
use App\Observers\GroupObserver;
use Illuminate\Http\Request;


/**
 *
 * Class ContactsApiController
 *
 * @package Modules\Api\Http\Controllers
 */
class GroupApiController extends Controller
{
    protected $entityClass = User::class;

    protected $storeRequest = GroupApiRequest::class;

    protected $updateRequest = GroupApiRequest::class;

    protected $repository = UserRepository::class;

    protected $moduleName = 'contacts';

    protected $languageFile = 'users::users';

    protected $with = [
        'contactStatus','contactSource','language','referral','country','account'
    ];

    protected $permissions = [
        'browse' => 'contacts.browse',
        'create' => 'contacts.create',
        'update' => 'contacts.update',
        'destroy' => 'contacts.destroy'
    ];

    public function __construct(RoleRepository $repository, UserService $userService)
    {
        $this->middleware('jwt.auth')->except('login');
        $this->GroupObserver = new GroupObserver();

    }

    /**
     * Get all groups via API.
     */
    public function index(Request $request)
    {
        try {
            $perPage = $request->get('per_page', 10);
            $user = auth()->user();
            $groups = Group::with('users')
                ->where('company_id', $user->company_id)
                ->whereNull('deleted_at')
                ->paginate($perPage);
            return response()->json([
                'success' => true,
                'data' => $groups
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage()
            ], 500);
        }
    }

    /**
     * Store a new group via API.
     */
    public function store()
    {
        $request = \App::make($this->storeRequest ?? Request::class);
        try {
            $user = auth()->user();
            $data = $request->all();
            $data['company_id'] = $user->company_id;

            // Check if all users belong to the same company
            if (isset($data['users']) && is_array($data['users']) && count($data['users']) > 0) {
                $userCount = User::whereIn('id', $data['users'])
                    ->where('company_id', $user->company_id)
                    ->whereNull('deleted_at')
                    ->count();
                if ($userCount !== count($data['users'])) {
                    return response()->json([
                        'success' => false,
                        'message' => 'One or more users do not belong to your company.'
                    ], 422);
                }
            }

            $groupRepo = \App::make(GroupRepository::class);
            $entity = $groupRepo->create($data);

            // Sync users if provided
            if (isset($data['users'])) {
                $entity->users()->sync($data['users']);
                $this->GroupObserver->created($data['users'], $entity);
            } else {
                $entity->users()->sync([]);
            }

            return response()->json([
                'success' => true,
                'message' => 'Group created successfully.',
                'data' => $entity
            ], 201);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage()
            ], 500);
        }
    }

    /**
     * Update an existing group via API.
     */
    public function update(Request $request, $id)
    {
        try {
            $user = auth()->user();
            $groupRepo = \App::make(GroupRepository::class);
            $entity = $groupRepo->where('id', $id)
                ->where('company_id', $user->company_id)
                ->whereNull('deleted_at')
                ->first();

            if (!$entity) {
                return response()->json([
                    'success' => false,
                    'message' => 'Group not found.'
                ], 404);
            }

            $data = $request->all();

            // Check if all users belong to the same company
            if (isset($data['users']) && is_array($data['users']) && count($data['users']) > 0) {
                $userCount = User::whereIn('id', $data['users'])
                    ->where('company_id', $user->company_id)
                    ->whereNull('deleted_at')
                    ->count();
                if ($userCount !== count($data['users'])) {
                    return response()->json([
                        'success' => false,
                        'message' => 'One or more users do not belong to your company.'
                    ], 422);
                }
            }

            $groupRepo->update($data, $id);

            // Sync users if provided
            if (isset($data['users'])) {
                $entity->users()->sync($data['users']);
                $this->GroupObserver->updated($entity, $data['users']);
            } else {
                $entity->users()->sync([]);
                $this->GroupObserver->updated($entity);
            }

            // Reload the entity with users
            $entity = Group::with('users')->find($id);

            return response()->json([
                'success' => true,
                'message' => 'Group updated successfully.',
                'data' => $entity
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage()
            ], 500);
        }
    }

    /**
     * Delete a group via API.
     */
    public function destroy($id)
    {
        try {
            $user = auth()->user();
            $group = Group::where('id', $id)
                ->where('company_id', $user->company_id)
                ->whereNull('deleted_at')
                ->first();
            if (!$group) {
                return response()->json([
                    'success' => false,
                    'message' => 'Group not found.'
                ], 404);
            }
            \DB::table('group_user')->where('group_id', $id)->delete();
            $group->delete();
            return response()->json([
                'success' => true,
                'message' => 'Group deleted successfully.'
            ]);
        } catch (\Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage()
            ], 500);
        }
    }
    

}