<?php

namespace App\Http\Controllers\Server\Admin;


use App\Http\Controllers\Controller;
use App\Models\CommunityActivity;
use App\Models\Course\Course;
use App\Models\Live\Anchor;
use App\Models\MerchantShop;
use App\Models\Server\AllianceMerchant;
use App\Models\Server\MarketService;
use App\Models\Server\MEarningRule;
use App\Models\Server\MerchantEvaluate;
use App\Models\Server\MerchantService;
use Illuminate\Http\Request;
use Illuminate\Http\JsonResponse;
use Illuminate\Support\Facades\DB;

class MarketServiceController extends Controller
{
    /**
     * 添加服务进入市场
     * @param Request $request
     * @return JsonResponse
     */
    public function addServiceToMarket(Request $request)
    {
        try {
            $merchant_id = $request->account_id;
            $type = $request->input('type');
            $type_id = $request->type_id;
            $ratio = $request->ratio;
            $forzen_time = $request->forzen_time;
            $protocol = $request->protocol;
           if (!$merchant_id || !$type || !$type_id || !isset($ratio)) {
               return $this->failure('参数不全');
           }
           switch ($type) {
               case 'course':
                   $service = Course::where('id', $type_id)->where('merchant_id', $merchant_id)
                       ->first();
                   break;
               case 'activity':
                   $service = CommunityActivity::where('id', $type_id)->where('merchant_id', $merchant_id)
                       ->where('class','one')
                       ->first();
                   break;
               case 'service':
                   $service = CommunityActivity::where('id', $type_id)->where('merchant_id', $merchant_id)
                       ->where('class','many')
                       ->first();
                   break;
               case 'community':
                   $service = CommunityActivity::where('id', $type_id)->where('merchant_id', $merchant_id)
                       ->first();
                   break;
               case 'shop':
                   $service = MerchantShop::where('id', $type_id)->where('merchant_id', $merchant_id)
                       ->first();
                   break;
               case 'evaluate':
                   $service = MerchantEvaluate::where('id', $type_id)->where('merchant_id', $merchant_id)
                       ->first();
                   break;
               default:
                   break;
           }
           if (!$service) {
               return $this->failure('服务不存在');
           }
           $market_service = MarketService::where('merchant_id', $merchant_id)->where('type', $type)
               ->where('type_id',$type_id)
               ->withTrashed()
               ->first();
           if (!$market_service) {
               $market_service = new MarketService();
               $market_service->merchant_id = $merchant_id;
               if($type == 'activity' || $type == 'service' || $type == 'community' ){
                   $market_service->type = 'community';
               }else{
                   $market_service->type = $type;
               }
               $market_service->type_id = $type_id;
               $market_service->status = 1;
               $market_service->ratio = number_format($request->ratio, 2);
               $market_service->forzen_time = $forzen_time;
               $market_service->protocol = $protocol;
               $market_service->save();
           } else {
               if($market_service->deleted_at){
                   $market_service->deleted_at = null;
               }
               $market_service->merchant_id = $merchant_id;
               if($type == 'activity' || $type == 'service' || $type == 'community' ){
                   $market_service->type = 'community';
               }else{
                   $market_service->type = $type;
               }
               $market_service->status = 1;
               $market_service->type_id = $type_id;
               $market_service->ratio = number_format($request->ratio, 2);
               $market_service->forzen_time = $forzen_time;
               $market_service->protocol = $protocol;
               $market_service->save();
           }
           return $this->success('ok');
       } catch (\Exception $e) {
           $this->getError($e);
           return $this->failure('服务器休息中，请稍后再试');
       }
   }

    /**
     * 获取市场服务列表
     * @param Request $request
     */
    public function getMarketServiceList(Request $request)
    {
        try {
            $type = $request->type;
            $keyword = $request->keyword;
            $merchant_id = $request->account_id;
            $market_type = $request->market_type ?? 1;
            $audit_status = $request->audit_status;
            if (!$type) {
                return $this->failure('服务类型为必传参数');
            }
            $marketService = MarketService::with('merchant:id,share_title,share_icon');
            if ($type == 'activity' || $type == 'service' || $type == 'community') {
                $marketService = $marketService->join('community_activities', function ($join) use ($request, $type) {
                    $join->on('community_activities.id', '=', 'market_services.type_id')
                        ->whereNull('market_services.deleted_at');
                    if ($type == 'activity') {
                        $join->where('community_activities.class', 'one');
                    }
                    if ($type == 'service') {
                        $join->where('community_activities.class', 'many');
                    }
                }, null, null, 'right')
                    ->join('merchant_services', function ($join) use ($request, $type, $merchant_id) {
                        $join->on('merchant_services.type_id', '=', 'market_services.type_id')
                            ->where('merchant_services.merchant_id', $merchant_id)
                            ->where('merchant_services.type', 'community')
                            ->whereNull('merchant_services.deleted_at');
                    }, null, null, 'left')
                    ->where('market_services.type', 'community')
                    ->select('community_activities.title', 'community_activities.pic', 'community_activities.price',
                        'market_services.ratio', 'market_services.created_at', 'merchant_services.id as service_id', 'market_services.type_id',
                        'merchant_services.service_type', 'community_activities.merchant_id', 'community_activities.id');;
            }
            if ($type == 'course') {
                $marketService = $marketService->join('courses', function ($join) use ($request, $type) {
                    $join->on('courses.id', '=', 'market_services.type_id')
                        ->where('courses.is_show', 1)
                        ->whereNull('market_services.deleted_at');
                }, null, null, 'right')
                    ->join('merchant_services', function ($join) use ($request, $type, $merchant_id) {
                        $join->on('merchant_services.type_id', '=', 'market_services.type_id')
                            ->where('merchant_services.merchant_id', $merchant_id)
                            ->where('merchant_services.type', 'course')
                            ->whereNull('merchant_services.deleted_at');
                    }, null, null, 'left')
                    ->when($market_type == 2, function ($query) use($merchant_id) {
                        $query->where('market_services.alliance_id',$merchant_id)->where('market_services.market_type', 2);
                    })
                    ->when($market_type == 1, function ($query) {
                        $query->where('market_services.market_type', 1);
                    })
                    ->when(isset($audit_status), function ($query) use ($audit_status) {
                        $query->where('audit_status', $audit_status);
                    })
                    ->where('market_services.type', 'course')
                    ->select('courses.title', 'courses.thumb', 'courses.charge', 'market_services.ratio',
                        'market_services.created_at', 'merchant_services.id as service_id', 'market_services.audit_status',
                        'merchant_services.service_type', 'courses.merchant_id', 'courses.id', 'market_services.audit_info');
            }
            if ($keyword) {
                if ($type == 'activity' || $type == 'service' || $type == 'community') {
                    $marketService = $marketService->where('community_activities.title', 'like', "%$keyword%");
                }
                if ($type == 'course') {
                    $marketService = $marketService->where('title', 'like', "%$keyword%");
                }
                if ($type == 'shop') {
                    $marketService = $marketService->where('title', 'like', "%$keyword%");
                }
                if ($type == 'evaluate') {
                    $marketService = $marketService->where('title', 'like', "%$keyword%");
                }
            }
            $marketService = $marketService->orderBy('market_services.created_at','desc')
                ->paginate();
            return $this->success('ok', $marketService);
        } catch (\Exception $e) {
            $this->getError($e);
            return $this->failure('服务器休息中，请稍后再试');
        }
    }

    /**
     * 从服务市场添加服务到我的服务
     * @param Request $request
     * @return JsonResponse
     */
    public function addServiceFromMarket(Request $request)
    {
        try {
            $merchant_id = $request->account_id;
            $type = $request->input('type');
            $type_id = $request->type_id;
            if (!$type || !$type_id) {
                return $this->failure('参数不全');
            }
            //联盟不能从服力市场拉取服务
            $anchor = Anchor::where('m_id',$merchant_id)->first();
            if($anchor && $anchor->service_nature == 'alliance'){
                return $this->failure('联盟不能暂时不支持添加服务市场的服务');
            }
            $marketService = MarketService::where('market_services.status', 1);
            if ($type == 'activity' || $type == 'service' || $type == 'community') {
                $marketService = $marketService->join('community_activities', function ($join) use ($request, $type, $type_id) {
                    $join->on('community_activities.id', '=', 'market_services.type_id')
                        ->whereNull('market_services.deleted_at');
                    if ($type == 'activity') {
                        $join->where('community_activities.class', 'one');
                    }
                    if ($type == 'service') {
                        $join->where('community_activities.class', 'many');
                    }
                    $join->where('community_activities.id', $type_id);
                }, null, null, 'right')
                    ->where('market_services.type', 'community')
                    ->where('market_services.type_id', $type_id)
                    ->select('community_activities.*')
                    ->first();
                $type = 'community';
            }
            if ($type == 'course') {
                $marketService = $marketService->join('courses', function ($join) use ($request, $type, $type_id) {
                    $join->on('courses.id', '=', 'market_services.type_id')
                        ->whereNull('market_services.deleted_at');
                }, null, null, 'right')
                    ->where('market_services.type', 'course')
                    ->where('market_services.type_id', $type_id)
                    ->select('courses.is_show as status', 'courses.merchant_id', 'courses.id', 'market_services.type_id')
                    ->first();
            }
            if (!$marketService || $marketService->status == 0) {
                return $this->failure('服务不存在或已下架');
            } else {
                if ($marketService->merchant_id == $merchant_id) {
                    return $this->failure('不能添加自己提供的服务');
                }
            }
            $merchant_service = MerchantService::where('type', $type)
                ->where('type_id', $type_id)
                ->withTrashed()
                ->where('merchant_id', $merchant_id)
                ->first();

//            DB::beginTransaction();
            if (!$merchant_service) {
                $merchant_service = new MerchantService();
                $merchant_service->merchant_id = $merchant_id;
                if ($type == 'activity' || $type == 'service' || $type == 'community') {
                    $merchant_service->type = 'community';
                } else {
                    $merchant_service->type = $type;
                }
                $merchant_service->service_type = 1;
                $merchant_service->status = 1;
                $merchant_service->type_id = $type_id;
                $merchant_service->save();
            } else {
                if ($merchant_service->deleted_at) {
                    $merchant_service->deleted_at = null;
                    $merchant_service->save();
                }
            }
//            if ($request->account_id == 596) {
//                $ratio = $request->input('ratio', 0);
//                $forzen_time = $request->input('forzen_time', 1);
//                $default_rule = MEarningRule::where('m_id', $request->account_id)
//                    ->where('name', $type)
//                    ->where('type_id', 0)
//                    ->first();
//                $rule = new MEarningRule;
//                $rule->m_id = $request->account_id;
//                $rule->forzen_time = $forzen_time;
//                $rule->ratio = $ratio;
//                $rule->type_id = $type_id;
//                $rule->first_sharer = $default_rule ? $default_rule->first_sharer : MEarningRule::DEFAULT_FIRST_SHARER;
//                $rule->last_sharer = $default_rule ? $default_rule->last_sharer : MEarningRule::DEFAULT_LAST_SHARER;
//                $rule->other_sharer = $default_rule ? $default_rule->other_sharer : MEarningRule::DEFAULT_OTHER_SHARER;
//                $rule->save();
//            }
//            DB::commit();

            return $this->success('ok');
        } catch (\Exception $e) {
            $this->getError($e);
            return $this->failure('服务器休息中，请稍后再试');
        }
    }

    /**
     * 把我的服务从服务市场下架
     */
    public function deletedMyMarketService(Request $request)
    {
        try {
            $merchant_id = $request->account_id;
            $type_id = $request->type_id;
            $type = $request->type;
            $market_type = $request->market_type ?? 1;
            $service_type = $request->service_type ?? 1;
            if (!$type || !$type_id) {
                return $this->failure('参数不全');
            }
            if ($type == 'activity' || $type == 'service' || $type == 'community') {
                $type = 'community';
            }
            $market_servive = MarketService::where('merchant_id', $merchant_id)
                ->where('type', $type)
                ->where('type_id', $type_id)
                ->where('market_type', $market_type)
                ->first();
            if (!$market_servive) {
                return $this->failure('服务不存在');
            }
            $market_servive->delete();
            MerchantService::where('type_id', $type_id)
                ->where('service_type',$service_type)
                ->where('type', $type)
                ->delete();
            return $this->success('ok');
        } catch (\Exception $e) {
            $this->getError($e);
            return $this->failure('服务器休息中，请稍后再试');
        }
    }

    /**
     * 同步服务或活动到merchant_service
     * @param Request $request
     * @return JsonResponse
     */
    public function syncActivity(Request $request)
    {
        try {
            $activity_ids = CommunityActivity::whereNull('deleted_at')
                ->get();
            foreach ($activity_ids as $activity) {
                $merchant_service_old = MerchantService::where('type', 'community')
                    ->where('merchant_id', $activity->merchant_id)
                    ->where('type_id', $activity->id)
                    ->first();
                if (!$merchant_service_old) {
                    $merchant_service = new MerchantService();
                    $merchant_service->merchant_id = $activity->merchant_id;
                    $merchant_service->type = 'community';
                    $merchant_service->status = $activity->status;
                    $merchant_service->type_id = $activity->id;
                    $merchant_service->sort = $activity->sort;
                    $merchant_service->is_top = $activity->is_top;
                    $merchant_service->top_time = $activity->top_time;
                    $merchant_service->service_type = 0;
                    $merchant_service->save();
                    unset($merchant_service);
                }
            }
            return $this->success('ok');
        } catch (\Exception $e) {
            $this->getError($e);
            return $this->failure('服务器休息中，请稍后再试');
        }
    }

    /**
     * 同步课程
     * @param Request $request
     */
    public function syncCourse(Request $request)
    {
        try {
            $course_ids = Course::whereNull('deleted_at')
                ->get();
            foreach ($course_ids as $course) {
                if (!$course->merchant_id) {
                    continue;
                }
                $old_course = MerchantService::where('type', 'course')
                    ->where('merchant_id', $course->merchant_id)
                    ->where('type_id', $course->id)
                    ->first();
                if (!$old_course) {
                    $merchant_service = new MerchantService();
                    $merchant_service->merchant_id = $course->merchant_id;
                    $merchant_service->type = 'course';
                    $merchant_service->status = $course->is_show;
                    $merchant_service->type_id = $course->id;
                    $merchant_service->sort = $course->sort;
                    $merchant_service->is_top = $course->is_top;
                    $merchant_service->top_time = $course->top_time;
                    $merchant_service->service_type = 0;
                    $merchant_service->save();
                    unset($merchant_service);
                }
            }
        } catch (\Exception $e) {
            $this->getError($e);
            return $this->failure('服务器休息中，请稍后再试');
        }
        return $this->success('ok');
    }

    /**
     * 申请服务加入联盟市场
     */
    public function addServiceToAllianceMarket(Request $request)
    {
        try {
            $alliance_id = $request->alliance_id;
            $merchant_id = $request->account_id;
            $type = $request->type;
            $type_id = $request->type_id;
            $ratio = $request->ratio;
            if (!$alliance_id || !$type || !$type_id || !isset($ratio)) {
                return $this->failure('参数不全');
            }
            //检查服务是否存在
            switch ($type) {
                case 'course':
                    $service = Course::where('id', $type_id)->where('merchant_id', $merchant_id)
                        ->where('is_show', 1)
                        ->first();
                    break;
                case 'activity':
                    $service = CommunityActivity::where('id', $type_id)->where('merchant_id', $merchant_id)
                        ->where('status', 1)
                        ->where('class', 'one')
                        ->first();
                    break;
                case 'service':
                    $service = CommunityActivity::where('id', $type_id)->where('merchant_id', $merchant_id)
                        ->where('status', 1)
                        ->where('class', 'many')
                        ->first();
                    break;
                case 'community':
                    $service = CommunityActivity::where('id', $type_id)->where('merchant_id', $merchant_id)
                        ->where('status', 1)
                        ->first();
                    break;
                case 'shop':
                    $service = MerchantShop::where('id', $type_id)->where('merchant_id', $merchant_id)
                        ->where('is_show', 1)
                        ->first();
                    break;
                case 'evaluate':
                    $service = MerchantEvaluate::where('id', $type_id)->where('merchant_id', $merchant_id)
                        ->where('status', 1)
                        ->first();
                    break;
                default:
                    break;
            }
            if (!$service) {
                return $this->failure('服务不存在或已下架');
            }
            if ($alliance_id == $merchant_id) {
                return $this->failure('暂不支持联盟创建者添加自己的服务');
            }
            //检查是否联盟成员或联盟创建者
            $alliance_merchant = AllianceMerchant::where('alliance_id', $alliance_id)->where('mch_id', $merchant_id)
                ->where('audit_type', 2)
                ->first();
            if (!$alliance_merchant) {
                return $this->failure('您没有加入联盟或暂时未通过审核');
            }
            //是否添加到市场
            $market_service = MarketService::where('merchant_id', $merchant_id)
                ->where('alliance_id',$alliance_id)
                ->where('type', $type)->where('type_id', $type_id)
                ->where('market_type', 2)
                ->first();
            if ($market_service){
                if($market_service->audit_status == 0 || $market_service->audit_status == 1){
                    return $this->failure('服务已添加，请等待联盟管理员审核');
                }elseif($market_service->audit_status == 2){
                    $market_service->audit_status = 0;
                    $market_service->save();
                    return $this->success('ok');
                }
            }
            $merchant_service = new MarketService();
            $merchant_service->alliance_id = $alliance_id;
            $merchant_service->merchant_id = $merchant_id;
            $merchant_service->status = 0;
            $merchant_service->ratio = $ratio;
            $merchant_service->type = $type;
            $merchant_service->type_id = $type_id;
            $merchant_service->market_type = 2;
            $merchant_service->save();
            $alliance_anchor = Anchor::where('m_id',$alliance_id)->first();
            $alliance_member = Anchor::where('m_id',$merchant_id)->first();
            if($alliance_anchor && $alliance_anchor->mobile && $alliance_member && $alliance_member->mobile){
                $this->sentMessage($alliance_anchor->mobile, '商家:'.$alliance_member->name.' 申请将服务 '.$service->title.' 加入您的联盟市场');
            }
            return $this->success('ok');
        } catch (\Exception $e) {
            $this->getError($e);
            return $this->failure('服务器休息中，请稍后再试');
        }

    }

    /**
     * 联盟市场服务审核
     * @param Request $request
     */
    public function auditAllianceMarketService(Request $request)
    {
        try {
            $merchant_id = $request->account_id;
            $type = $request->type;
            $type_id = $request->type_id;
            $audit_status = $request->audit_status;
            $err_msg = $request->err_msg;
            if (!$type || !$type_id || !$audit_status) {
                return $this->failure('参数不全');
            }
            if ($audit_status < 1) {
                return $this->failure('不能回复到未审核状');
            }
            if ($audit_status == 2 && empty($err_msg)) {
                return $this->failure('审核不能过时须要提供理由');
            }
            //检查服务是否存在
            switch ($type) {
                case 'course':
                    $service = Course::where('id', $type_id)->where('is_show', 1)
                        ->first();
                    break;
                case 'activity':
                    $service = CommunityActivity::where('id', $type_id)->where('status', 1)
                        ->where('class', 'one')
                        ->first();
                    break;
                case 'service':
                    $service = CommunityActivity::where('id', $type_id)->where('status', 1)
                        ->where('class', 'many')
                        ->first();
                    break;
                case 'community':
                    $service = CommunityActivity::where('id', $type_id)->where('status', 1)
                        ->first();
                    break;
                case 'shop':
                    $service = MerchantShop::where('id', $type_id)->where('is_show', 1)
                        ->first();
                    break;
                case 'evaluate':
                    $service = MerchantEvaluate::where('id', $type_id)->where('status', 1)
                        ->first();
                    break;
                default:
                    break;
            }
            if (!$service) {
                return $this->failure('服务不存在或已下架');
            }
            //检查是否联盟创建者或联盟管理员
            $anchor = Anchor::where('m_id', $merchant_id)->where('service_nature', 'alliance')
                ->first();
            if (!$anchor) {
                return $this->failure('您不是联盟创建者或管理员，不能审核');
            }

            $market_service = MarketService::where('alliance_id', $merchant_id)
                ->where('type', $type)->where('type_id', $type_id)
                ->where('market_type', 2)->where('audit_status', 0)
                ->first();
            if (!$market_service) {
                return $this->failure('待审核服务不存在');
            }

            if ($market_service->audit_info) {
                $audit_info = json_decode($market_service->audit_info);
            }
            $audit_info[] = [
                'audited_at' => date('Y-m-d H:i:s'),
                'audit_admin_id' => $admin_id ?? 0,
                'audit_status' => $audit_status,
                'err_msg' => $err_msg,
            ];
            DB::beginTransaction();
            $market_service->audit_status = $audit_status;
            $market_service->err_msg = $err_msg;
            $market_service->audit_info = json_encode($audit_info);
            $market_service->save();

            //检查是否已添加到了服务
            $merchant_service = MerchantService::where('merchant_id', $merchant_id)
                ->where('type', $type)->where('type_id', $type_id)
                ->where('service_type', 2)
                ->first();

            if($audit_status ==1){
                if (!$merchant_service) {
                    $merchant_service = new MerchantService();
                    $merchant_service->merchant_id = $merchant_id;
                    $merchant_service->type = $type;
                    $merchant_service->status = 1;
                    $merchant_service->type_id = $type_id;
                    $merchant_service->service_type = 2;
                    $merchant_service->save();
                }
            }
            DB::commit();
            $alliance_anchor = Anchor::where('m_id',$merchant_id)->first();
            $alliance_member = Anchor::where('m_id',$service->merchant_id)->first();

            if($alliance_anchor && $alliance_anchor->mobile && $alliance_member && $alliance_member->mobile){
                if($audit_status ==1){
                    $status = '审核通过';
                }elseif($audit_status ==2){
                    $status = '审核拒绝';
                }else{
                    $status = '正在审核';
                }
                $this->sentMessage($alliance_member->mobile, '您提交的服务: '.$service->title.' '.$status);
            }
            return $this->success('ok');
        } catch (\Exception $e) {
            DB::rollBack();
            $this->getError($e);
            return $this->failure('服务器休息了，请稍后再试');
        }
    }
}