nshop/packages/Longyi/RewardPoints/src/Http/Controllers/RewardPointsController.php

<?php

namespace Longyi\RewardPoints\Http\Controllers;

use Illuminate\Support\Facades\Log;
use Longyi\RewardPoints\Models\RewardActiveRule;
use Longyi\RewardPoints\Repositories\RewardPointRepository;
use Longyi\RewardPoints\Repositories\RewardPointSettingRepository;
use Longyi\RewardPoints\Models\RewardPointCustomerSign;
use Longyi\RewardPoints\Helpers\ApiResponse;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
use Longyi\RewardPoints\Models\RewardPointHistory;
class RewardPointsController extends Controller
{
    protected $rewardPointRepository;
    protected $settingRepository;
    protected $_config;

    public function __construct(
        RewardPointRepository $rewardPointRepository,
        RewardPointSettingRepository $settingRepository
    ) {
        $this->rewardPointRepository = $rewardPointRepository;
        $this->settingRepository = $settingRepository;
        $this->_config = request('_config');
    }

    public function index()
    {
        $customer = auth()->guard('customer')->user();

        if (!$customer) {
            return redirect()->route('customer.session.index');
        }

        $points = $this->rewardPointRepository->getCustomerPoints($customer->id);
        $history = $this->rewardPointRepository->getHistory($customer->id);

        return view($this->_config['view'], compact('points', 'history'));
    }

    public function signIn()
    {
        $customer = auth()->guard('customer')->user();

        if (!$customer) {
            return ApiResponse::unauthorized();
        }

        // Check if sign in feature is enabled
        $signinEnabled = $this->settingRepository->getConfigValue('signin_enabled', true);
        if (!$signinEnabled) {
            return ApiResponse::forbidden('Sign in feature is disabled');
        }

        $today = Carbon::now()->format('Y-m-d');

        $existingSign = RewardPointCustomerSign::where('customer_id', $customer->id)
            ->where('sign_date', $today)
            ->first();

        if ($existingSign) {
            return ApiResponse::error('Already signed in today');
        }

        $lastSign = RewardPointCustomerSign::where('customer_id', $customer->id)
            ->orderBy('sign_date', 'desc')
            ->first();

        $countDate = 1;
        if ($lastSign) {
            $lastSignDate = Carbon::parse($lastSign->sign_date);
            $yesterday = Carbon::yesterday();

            if ($lastSignDate->toDateString() === $yesterday->toDateString()) {
                $countDate = $lastSign->count_date + 1;
            } elseif ($lastSignDate->toDateString() !== $today) {
                $countDate = 1;
            }
        }

        // Get sign in points from ly_mw_reward_points_settings table
        $points = $this->getSignInPointsByDay($countDate);

        // Create sign in record (Laravel auto-maintains created_at and updated_at)
        $sign = RewardPointCustomerSign::create([
            'customer_id' => $customer->id,
            'sign_date' => $today,
            'count_date' => $countDate,
            'point' => $points,
            'code' => uniqid('SIGN_')
        ]);

        // Add points to customer account
        $this->rewardPointRepository->addPoints(
            $customer->id,
       RewardActiveRule::TYPE_SIGN_IN,
            $points,
            null,
            "Daily sign-in reward (Day {$countDate})"
        );

        $totalPoints = $this->rewardPointRepository->getCustomerPoints($customer->id);

        return ApiResponse::success([
            'points' => $points,
            'streak' => $countDate,
            'total_points' => $totalPoints
        ], "Sign in successful! Earned {$points} points");
    }

    /**
     * Get sign in points by day from ly_mw_reward_points_settings table
     */
    protected function getSignInPointsByDay($day)
    {
        // Map sign in days to configuration codes
        $dayPointsMap = [
            1 => 'signin_day1_points',
            2 => 'signin_day2_points',
            3 => 'signin_day3_points',
            4 => 'signin_day4_points',
            5 => 'signin_day5_points',
            6 => 'signin_day6_points',
            7 => 'signin_day7_points',
        ];

        // If <= 7 days, use corresponding configuration
        if ($day <= 7 && isset($dayPointsMap[$day])) {
            return (int) $this->settingRepository->getConfigValue($dayPointsMap[$day], 10);
        }

        // 8 days and beyond, use signin_day8_plus_points configuration
        return (int) $this->settingRepository->getConfigValue('signin_day8_plus_points', 70);
    }

    public function getSignStatus()
    {
        $customer = auth()->guard('customer')->user();
        if (!$customer) {
            return ApiResponse::unauthorized();
        }
        Log::info('Customer login event triggered');
        $today = Carbon::now()->format('Y-m-d');
        $signedToday = RewardPointCustomerSign::where('customer_id', $customer->id)
            ->where('sign_date', $today)
            ->exists();

        $lastSign = RewardPointCustomerSign::where('customer_id', $customer->id)
            ->orderBy('sign_date', 'desc')
            ->first();
        /*$currentGroup = 'sign_in';
        $settings = $this->settingRepository->getSettingsByGroup($currentGroup);*/
        return ApiResponse::success([
            'signed_today' => $signedToday,
            'current_streak' => $lastSign ? $lastSign->count_date : 0,
            'total_points' => $this->rewardPointRepository->getCustomerPoints($customer->id)
        ]);
    }

    /**
     * Get customer points history/records
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function getPointsHistory(Request $request)
    {
        $customer = auth()->guard('customer')->user();

        if (!$customer) {
            return ApiResponse::unauthorized();
        }

        // Get pagination parameters
        $page = $request->input('page', 1);
        $limit = $request->input('per_page', 20);

        // Validate limit
        $limit = min(max($limit, 1), 100); // Limit between 1 and 100

        // Get paginated history
        $history = $this->rewardPointRepository->getHistory($customer->id, $limit,$page);

        // Transform history data
        $transformedHistory = collect($history->items())->map(function ($item) {
            return [
                'id' => $item->history_id,
                'type' => $item->type_of_transaction,
                'type_text' => $this->getTransactionTypeText($item->type_of_transaction),
                'amount' => $item->amount,
                'balance' => $item->balance,
                'detail' => $item->transaction_detail,
                'order_id' => $item->history_order_id > 0 ? $item->history_order_id : null,
                'expired_day' => $item->expired_day,
                'expired_time' => $item->expired_time ? Carbon::parse($item->expired_time)->format('Y-m-d H:i:s') : null,
                'remaining_points' => $item->point_remaining,
                'status' => $item->status,
                'status_text' => $this->getStatusText($item->status),
                'created_at' => Carbon::parse($item->transaction_time)->format('Y-m-d H:i:s'),
            ];
        });

        return ApiResponse::success([
            'current_points' => $this->rewardPointRepository->getCustomerPoints($customer->id),
            'history' => $transformedHistory,
            'pagination' => [
                'current_page' => $history->currentPage(),
                'per_page' => $history->perPage(),
                'total' => $history->total(),
                'last_page' => $history->lastPage(),
                'has_more' => $history->hasMorePages()
            ]
        ]);
    }

    /**
     * Get customer points summary
     *
     * @return \Illuminate\Http\JsonResponse
     */
    public function getPointsSummary()
    {
        $customer = auth()->guard('customer')->user();

        if (!$customer) {
            return ApiResponse::unauthorized();
        }

        $totalPoints = $this->rewardPointRepository->getCustomerPoints($customer->id);

        // Get today's sign in status
        $today = Carbon::now()->format('Y-m-d');
        $signedToday = RewardPointCustomerSign::where('customer_id', $customer->id)
            ->where('sign_date', $today)
            ->exists();

        // Get current streak
        $lastSign = RewardPointCustomerSign::where('customer_id', $customer->id)
            ->orderBy('sign_date', 'desc')
            ->first();
        $currentStreak = $lastSign ? $lastSign->count_date : 0;

        // Get total earned points (all time)
        $totalEarned = RewardPointHistory::where('customer_id', $customer->id)
            ->where('amount', '>', 0)
            ->sum('amount');

        // Get total used points (all time)
        $totalUsed = RewardPointHistory::where('customer_id', $customer->id)
                ->where('amount', '<', 0)
                ->sum('amount') * -1;

        return ApiResponse::success([
            'current_points' => $totalPoints,
            'total_earned' => $totalEarned,
            'total_used' => $totalUsed,
            'signed_today' => $signedToday,
            'current_streak' => $currentStreak,
            'points_value' => $totalPoints * (float) $this->settingRepository->getConfigValue('point_value', 0.01)
        ]);
    }

    /**
     * Apply reward points to cart
     */
    public function applyPoints(Request $request)
    {
        $points = $request->input('points', 0);

        $cartRewardPoints = app('cartrewardpoints');
        $validation = $cartRewardPoints->validatePoints($points);

        if ($validation !== true) {
            return ApiResponse::error($validation);
        }

        $result = $cartRewardPoints->applyPoints($points);

        if ($result) {
            $discountDetails = $cartRewardPoints->getDiscountDetails();

            return ApiResponse::success([
                'discount' => $discountDetails
            ], 'Reward points applied successfully');
        }

        return ApiResponse::error('Failed to apply reward points');
    }

    /**
     * Remove reward points from cart
     */
    public function removePoints()
    {
        $cartRewardPoints = app('cartrewardpoints');
        $cartRewardPoints->removePoints();

        return ApiResponse::success([], 'Reward points removed successfully');
    }

    /**
     * Get points information for cart
     */
    public function getPointsInfo()
    {
        $cartRewardPoints = app('cartrewardpoints');

        return ApiResponse::success([
            'available_points' => $cartRewardPoints->getAvailablePoints(),
            'points_used' => $cartRewardPoints->getPointsUsed(),
            'discount_amount' => $cartRewardPoints->getDiscountAmount(),
            'points_value' => $cartRewardPoints->getPointsValue(1),
            'max_points_allowed' => $cartRewardPoints->getMaxPointsByCartTotal()
        ]);
    }

    /**
     * Get transaction type text
     */
    protected function getTransactionTypeText($type)
    {
        $types = [
            1 => 'Daily Sign In',
            2 => 'Registration',
            3 => 'Order Purchase',
            4 => 'Product Review',
            5 => 'Referral',
            6 => 'Birthday',
            7 => 'Share',
            8 => 'Subscription',
            9 => 'Login',
        ];

        return $types[$type] ?? 'Unknown';
    }

    /**
     * Get status text
     */
    protected function getStatusText($status)
    {
        $statuses = [
            1 => 'Completed',
            0 => 'Pending',
            3 => 'Expired',
            2 => 'Cancelled'
        ];

        return $statuses[$status] ?? 'Unknown';
    }
}