<?php

namespace App\Http\Controllers\admin;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use App\Helpers\helper;
use App\Models\Category;
use App\Models\Subcategory;
use App\Models\Item;
use App\Models\Variation;
use App\Models\Banner;
use App\Models\Ratting;
use App\Models\ItemImages;
use App\Models\GlobalExtras;
use App\Models\Extra;
use App\Models\Cart;
use App\Models\Tax;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Str;

class ItemController extends Controller
{
    public function index(Request $request)
    {
        $getitem = Item::with('category_info', 'subcategory_info', 'variation', 'item_image')->select('item.*')->where('item.is_deleted', '2');
        if ($request->has('search') && $request->search != "") {
            $search = $request->search;
            $getitem = $getitem->where(function ($query) use ($search) {
                $query->where('item.item_name', 'like', '%' . $search . '%');
            });
        }
        if ($request->has('option') && $request->option != "") {
            $getitem = $getitem->where('item.item_type', $request->option == "veg" ? 1 : 2);
        }
        $getitem = $getitem->orderBy('item.reorder_id')->get();
        return view('admin.item.item', compact('getitem'));
    }
    public function additem()
    {
        $getcategory = Category::where('is_available', '1')->where('is_deleted', '2')->orderBy('reorder_id')->get();

        $gettaxlist = Tax::where('is_deleted', 2)->where('is_available', 1)->orderBy('reorder_id')->get();
        $globalextras = GlobalExtras::where('is_available', 1)->orderBy('reorder_id')->get();
        return view('admin.item.additem', compact('getcategory', 'gettaxlist', 'globalextras'));
    }
    public function edititem($id)
    {

        $getitem = Item::with('category_info', 'subcategory_info', 'item_image', 'item_images', 'extras')->where('id', $id)->first();
        $globalextras = GlobalExtras::where('is_available', 1)->orderBy('reorder_id')->get();
        $getitemimages = ItemImages::where('item_id', $id)->orderBy('reorder_id')->get();
        $getsubcategory = Subcategory::where('cat_id', $getitem->cat_id)->where('is_available', '1')->where('is_deleted', '2')->orderBy('reorder_id')->get();

        $gettaxlist = Tax::where('is_deleted', 2)->where('is_available', 1)->orderBy('reorder_id')->get();
        $productVariantArrays = [];
        if (!empty($getitem)) {
            $getcategory = Category::where('is_available', '1')->where('is_deleted', '2')->get();
            $product_variant_names = [];
            $variant_options = [];
            if ($getitem->has_variation == '1') {
                $productVariants = Variation::where('item_id', $getitem->id)->get();

                if (!empty(json_decode($getitem->variants_json, true))) {

                    $variant_options = array_column(json_decode($getitem->variants_json), 'variant_name');
                    $product_variant_names = $variant_options;
                }

                foreach ($productVariants as $key => $productVariant) {
                    $productVariantArrays[$key]['product_variants'] = $productVariant->toArray();
                }
            }
            return view('admin.item.edititem', compact('getitem', 'getcategory', 'getsubcategory', 'getitemimages', 'productVariantArrays', 'product_variant_names', 'variant_options', 'gettaxlist', 'globalextras'));
        }
    }
    public function store(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'image.*' => 'image|max:' . helper::imagesize() . '|' . helper::imageext(),
        ], [
            'image.max' => trans('messages.image_size_message'),
        ]);
        if ($validator->fails()) {
            return redirect()->back()->with('error', trans('messages.image_size_message') . ' ' . helper::appdata('')->image_size . ' ' . 'MB');
        }
        $item = new Item;
        $item->cat_id = $request->cat_id;
        $item->subcat_id = $request->subcat_id == "" ? "" : $request->subcat_id;
        $item->preparation_time = "";

        $item->item_name = $request->item_name;
        $item->slug = $this->getitemslug($request->item_name, '');
        $item->item_type = $request->item_type;
        $item->has_variation = $request->has_variants;
        $item->sku = $request->sku;
        $item->video_url = $request->video_url;
        if ($request->has_variants == 1) {
            $variants_json = json_decode($request->hiddenVariantOptions, true);
            $variant_options = array_column($variants_json, 'variant_options');
            $possibilities = Item::possibleVariants($variant_options);

            foreach ($possibilities as $key => $possibility) {
                $price = $request->verians[$key]['price'];
                $qty = $request->verians[$key]['qty'];
                $original_price = $request->verians[$key]['original_price'];
                break;
            }
        } else {
            $price = $request->price;
            $original_price = $request->original_price;
            $qty = $request->qty;
        }
        if ($request->has_variants == 1) {
            $item->variants_json = $request->hiddenVariantOptions;
        } else {
            $item->variants_json = "";
        }
        $item->stock_management = $request->has_stock;
        $item->price = $price;
        $item->original_price = $original_price;

        if ($request->has_stock == 1) {
            $item->qty = $qty;
            $item->min_order = $request->min_order;
            $item->max_order = $request->max_order;
            $item->low_qty = $request->low_qty;
        } else {
            $item->qty = "";
            $item->low_qty = "";
            $item->min_order = "";
            $item->max_order = "";
        }
        $item->item_description = $request->description;
        $item->tax =  $request->tax != null ? implode('|', $request->tax) : '';
        if ($item->save()) {
            if ($request->has_variants == 1) {
                $item->variants_json = json_decode($item->variants_json, true);
                $variant_options = array_column($item->variants_json, 'variant_options');
                $possibilities = Item::possibleVariants($variant_options);
                foreach ($possibilities as $key => $possibility) {
                    $VariantOption = new Variation();
                    $VariantOption->name = $possibility;
                    $VariantOption->item_id = $item->id;
                    $VariantOption->price =  array_key_exists('price', $request->verians[$key]) ? $request->verians[$key]['price'] : '';
                    $VariantOption->qty = array_key_exists('qty', $request->verians[$key]) ? $request->verians[$key]['qty'] : '';
                    $VariantOption->original_price = array_key_exists('original_price', $request->verians[$key]) ? $request->verians[$key]['original_price'] : '';
                    $VariantOption->min_order =  array_key_exists('min_order', $request->verians[$key]) ? $request->verians[$key]['min_order'] : '';
                    $VariantOption->max_order =  array_key_exists('max_order', $request->verians[$key]) ?  $request->verians[$key]['max_order'] : '';
                    $VariantOption->low_qty =  array_key_exists('low_qty', $request->verians[$key]) ? $request->verians[$key]['low_qty'] : '';
                    $VariantOption->stock_management = array_key_exists('stock_management', $request->verians[$key]) ? $request->verians[$key]['stock_management'] : 2;
                    $VariantOption->is_available = array_key_exists('is_available', $request->verians[$key]) ? 1 : 2;
                    $VariantOption->save();
                }
            }
            // $img->move(env('ASSETSPATHURL').'admin-assets/images/item', $image);
            foreach ($request->file('image') as $img) {
                $itemimage = new ItemImages;
                $image = 'item-' . uniqid() . '.' . $img->getClientOriginalExtension();
                $img->move(env('ASSETSPATHURL') . 'admin-assets/images/item', $image);
                $itemimage->item_id = $item->id;
                $itemimage->image = $image;
                $itemimage->save();
            }
            if ($request->extras_name != null && $request->extras_name != "") {
                foreach ($request->extras_name as $key => $no) {
                    if (@$no != "" && @$request->extras_price[$key] != "") {
                        $extras = new Extra();
                        $extras->item_id = $item->id;
                        $extras->name = $no;
                        $extras->price = $request->extras_price[$key];
                        $extras->save();
                    }
                }
            }
            return redirect('admin/item')->with('success', trans('messages.success'));
        } else {
            return redirect()->back()->with('error', trans('messages.wrong'));
        }
    }
    public function storeimages(Request $request)
    {
        $error_array = array();
        $success_output = '';
        $validator = Validator::make($request->all(), [
            'file.*' => 'image|max:' . helper::imagesize() . '|' . helper::imageext(),
        ], [
            'file.max' => trans('messages.image_size_message'),
        ]);
        if ($validator->fails()) {
            return redirect()->back()->with('error', trans('messages.image_size_message') . ' ' . helper::appdata('')->image_size . ' ' . 'MB');
        } else {
            if ($request->hasFile('file')) {
                $files = $request->file('file');
                foreach ($files as $file) {
                    $itemimage = new ItemImages;
                    $image = 'item-' . uniqid() . '.' . $file->getClientOriginalExtension();
                    $file->move(env('ASSETSPATHURL') . 'admin-assets/images/item', $image);
                    $itemimage->item_id = $request->itemid;
                    $itemimage->image = $image;
                    $itemimage->save();
                }
            }
            $success_output = trans('messages.success');
        }
        $output = array('error'     =>  $error_array, 'success'   =>  $success_output);
        echo json_encode($output);
    }
    public function showimage(Request $request)
    {
        $getitem = ItemImages::where('id', $request->id)->first();
        if ($getitem->image) {
            $getitem->img = url(env('ASSETSPATHURL') . 'admin-assets/images/item/' . $getitem->image);
        }
        return response()->json(['ResponseCode' => 1, 'ResponseText' => trans('messages.success'), 'ResponseData' => $getitem], 200);
    }
    public function update(Request $request)
    {
        if ($request->has_variants == 1) {
            if ($request->verians == null && $request->variants == null) {
                return redirect('admin/products/edit-' . $request->slug)->with('error', trans('messages.variation_required'));
            }
        }
        if ($request->has_variants == 1) {
            $variants_json = json_decode($request->hiddenVariantOptions, true);
            $variant_options = array_column($variants_json, 'variant_options');
            $newpossibilities = Item::possibleVariants($variant_options);
            if ($request->verians == null) {
                foreach ($request->variants as $key => $possibility) {
                    $price = $request->variants[$key]['price'];
                    $qty = $request->variants[$key]['qty'];
                    $original_price = $request->variants[$key]['original_price'];
                    break;
                }
            } else {
                foreach ($newpossibilities as $key => $possibility) {
                    $price = $request->verians[$key]['price'];
                    $qty = $request->verians[$key]['qty'];
                    $original_price = $request->verians[$key]['original_price'];
                    break;
                }
            }
        } else {
            $price = $request->price;
            $original_price = $request->original_price;
            $qty = $request->qty;
        }

        $deletefromcart = Cart::where('item_id', $request->id)->delete();
        $item = Item::find($request->id);
        $item->cat_id = $request->cat_id;
        $item->subcat_id = $request->subcat_id == "" ? "" : $request->subcat_id;
        $item->preparation_time = "";

        $item->item_type = $request->item_type;
        $item->has_variation = $request->has_variants;
        $item->price = $price;
        $item->original_price = $original_price;
        $item->qty = $qty;
        $item->item_name = $request->item_name;
        $item->slug = $this->getitemslug($request->item_name, $request->id);;
        $item->item_description = $request->description;
        $item->tax =  $request->tax != null ? implode('|', $request->tax) : '';
        $item->sku = $request->sku;
        $item->video_url = $request->video_url;
        if ($request->has_variants == '1') {
            $item['has_variation'] = '1';
            $item['variants_json'] = !empty($request->hiddenVariantOptions) ? $request->hiddenVariantOptions : $item->variants_json;

            if (!empty($request->verians) && count($request->verians) > 0) {

                foreach ($request->verians as $key => $possibility) {
                    $possibilities = Variation::where('id', $key)->where('item_id', $item->id)->first();
                    if (is_null($possibilities)) {
                        $VariantOptionNew = new Variation();
                        $VariantOptionNew->item_id = $item->id;
                        $VariantOptionNew->name = $possibility['name'];
                        $VariantOptionNew->price = $possibility['price'];
                        $VariantOptionNew->original_price = $possibility['original_price'];
                        $VariantOptionNew->qty = $possibility['qty'] ?? $possibility['qty'];
                        $VariantOptionNew->min_order = $possibility['min_order'] ?? $possibility['min_order'];
                        $VariantOptionNew->max_order = $possibility['max_order'] ?? $possibility['max_order'];
                        $VariantOptionNew->low_qty =  $possibility['low_qty'];
                        $VariantOptionNew->stock_management = array_key_exists('stock_management', $possibility) ? $possibility['stock_management'] : 2;
                        $VariantOptionNew->is_available = array_key_exists('is_available',  $possibility) ?  $possibility['is_available'] : 2;
                        $VariantOptionNew->save();
                    } else {

                        $possibilities->price = $possibility['price'];
                        $possibilities->original_price = $possibility['original_price'];
                        $possibilities->qty = $possibility['qty'] ?? $possibility['qty'];
                        $possibilities->min_order = $possibility['min_order'] ?? $possibility['min_order'];
                        $possibilities->max_order = $possibility['max_order'] ?? $possibility['max_order'];
                        $possibilities->low_qty = $possibility['low_qty'] ?? $possibility['low_qty'];
                        $possibilities->stock_management = array_key_exists('stock_management', $possibility) ? $possibility['stock_management'] : 2;
                        $possibilities->is_available = array_key_exists('is_available',  $possibility) ?  $possibility['is_available'] : 2;
                        $possibilities->save();
                    }
                }
            } else if (!empty($request->variants) && count($request->variants) > 0) {

                foreach ($request->variants as $key => $possibility) {
                    $possibilities = Variation::find($key);
                    $possibilities->price = $possibility['price'];
                    $possibilities->original_price = $possibility['original_price'];
                    $possibilities->qty = $possibility['qty'] ?? $possibility['qty'];
                    $possibilities->min_order = $possibility['min_order'] ?? $possibility['min_order'];
                    $possibilities->max_order = $possibility['max_order'] ?? $possibility['max_order'];
                    $possibilities->low_qty = $possibility['low_qty'] ?? $possibility['low_qty'];
                    $possibilities->stock_management = array_key_exists('stock_management', $possibility) ? $possibility['stock_management'] : 2;
                    $possibilities->is_available = array_key_exists('is_available',  $possibility) ?  $possibility['is_available'] : 2;
                    if (!array_key_exists('is_available',  $possibility)) {

                        $carts = Cart::where('variation_id', $possibilities->id)->get();
                        foreach ($carts as $cart) {
                            $cart->delete();
                        }
                    }
                    $possibilities->save();
                }
            }
        } else {
            $item['has_variation'] = '2';
        }
        $item->stock_management = $request->has_stock;
        if ($request->has_stock == 1) {
            $item->qty = $qty;
            $item->low_qty = $request->low_qty;
            $item->min_order = $request->min_order;
            $item->max_order = $request->max_order;
        } else {
            $item->qty = "";
            $item->low_qty = "";
            $item->min_order = "";
            $item->max_order = "";
        }

        if ($request->has_variants == 2) {
            Variation::where('item_id', $request->id)->delete();
            $item->variants_json = '';
        }
        $carts = Cart::where('item_id', $item->id)->delete();

        $item->save();
        if ($request->has_variants == 1) {
            if (!empty($request->variants)) {

                foreach ($request->variants as $key => $variant) {
                    $newVal = '';

                    foreach (array_values($variant['variants']) as $k => $v) {
                        if (!empty($newVal)) {
                            $newVal .= '|' . $v[0];
                        } else {
                            $newVal .= $v[0];
                        }
                    }
                    $VariantOption = Variation::find($key);
                    $VariantOption->name = $newVal;
                    $VariantOption->price = $variant['price'];
                    $VariantOption->original_price = $variant['original_price'];
                    $VariantOption->qty = $variant['qty'] ?? $variant['qty'];
                    $VariantOption->min_order = $variant['min_order'] ?? $variant['min_order'];
                    $VariantOption->max_order = $variant['max_order'] ?? $variant['max_order'];
                    $VariantOption->low_qty = $variant['low_qty'] ?? $variant['low_qty'];
                    $VariantOption->stock_management = array_key_exists('stock_management',  $variant) ?  $variant['stock_management'] : 2;
                    $VariantOption->is_available = array_key_exists('is_available',  $variant) ?  $variant['is_available'] : 2;
                    $VariantOption->save();
                }
            }
        }
        $extras_id = $request->extras_id;
        if ($request->has_extras == 1) {
            if ($request->extras_name != null && $request->extras_name != "") {
                foreach ($request->extras_name as $key => $no) {
                    if (@$no != "" && @$request->extras_price[$key] != "") {
                        if (@$extras_id[$key] == "") {
                            $extras = new Extra();
                            $extras->item_id = $item->id;
                            $extras->name = $no;
                            $extras->price = $request->extras_price[$key];
                            $extras->save();
                        } else if (@$extras_id[$key] != "") {
                            Extra::where('id', @$extras_id[$key])->update(['name' => $request->extras_name[$key], 'price' => $request->extras_price[$key]]);
                        }
                    }
                }
            }
        } else {
            Extra::where('item_id', $item->id)->delete();
        }
        if ($item) {
            return redirect('admin/item')->with('success', trans('messages.success'));
        } else {
            return redirect()->back()->with('error', trans('messages.wrong'));
        }
    }
    public function updateimage(Request $request)
    {
        $validation = Validator::make($request->all(), ['image' => 'image']);
        $error_array = array();
        $success_output = '';
        if ($validation->fails()) {
            foreach ($validation->messages()->getMessages() as $field_name => $messages) {
                $error_array[] = $messages;
            }
        } else {
            $validator = Validator::make($request->all(), [
                'image' => 'image|max:' . helper::imagesize() . '|' . helper::imageext(),
            ], [
                'image.max' => trans('messages.image_size_message'),
            ]);
            if ($validator->fails()) {
                return redirect()->back()->with('error', trans('messages.image_size_message') . ' ' . helper::appdata('')->image_size . ' ' . 'MB');
            }
            $itemimage = ItemImages::find($request->id);
            if ($request->hasFile('image')) {
                $image = 'item-' . uniqid() . '.' . $request->image->getClientOriginalExtension();
                $request->image->move(env('ASSETSPATHURL') . 'admin-assets/images/item', $image);
                $itemimage->image = $image;
            }
            $itemimage->save();
            $success_output = trans('messages.success');
        }
        $output = array('error' => $error_array, 'success' => $success_output);
        echo json_encode($output);
    }
    public function getitemslug($item_name, $id)
    {
        $slug = Str::slug($item_name, '-');
        $checkslug = Item::where('slug', $slug);
        if ($id != "") {
            $checkslug = $checkslug->where('id', '!=', $id);
        }
        $checkslug = $checkslug->first();
        if (!empty($checkslug)) {
            $lastid = Item::select('id')->orderByDesc('id')->first();
            $slug .= '-' . $lastid->id;
        }
        return $slug;
    }

    public function reorder_item(Request $request)
    {
        $getitem = Item::all();
        foreach ($getitem as $item) {
            foreach ($request->order as $order) {
                $it = Item::where('id', $order['id'])->first();
                $it->reorder_id = $order['position'];
                $it->save();
            }
        }
        return response()->json(['status' => 1, 'msg' => 'Update Successfully!!'], 200);
    }

    public function status(Request $request)
    {
        $UpdateDetails = Item::where('id', $request->id)->update(['item_status' => $request->status]);
        if ($UpdateDetails) {
            $deletefromcart = Cart::where('item_id', $request->id)->delete();
            return 1;
        } else {
            return 0;
        }
    }
    public function delete(Request $request)
    {

        try {
            $checkproduct = Item::where('id', $request->id)->first();
            $checkvariation = Variation::where('item_id', $checkproduct->id)->delete();
            $checkextras = Extra::where('item_id', $checkproduct->id)->delete();
            $productimage = ItemImages::where('item_id', $checkproduct->id)->get();
            $getbanner = Banner::where('item_id', $checkproduct->id)->get();
            foreach ($getbanner as $banner) {
                $banner->type = "";
                $banner->product_id = "";
                $banner->update();
            }
            foreach ($productimage as $image) {
                if ($image->is_imported == 2) {
                    if ($image->image != "" && $image->image != null && file_exists(storage_path('app/public/item/' . $image->image))) {
                        unlink(storage_path('app/public/item/' . $image->image));
                    }
                }
                $image->delete();
            }
            Cart::where('item_id', $checkproduct->id)->delete();
            $checkproduct->delete();
            return 1;
        } catch (\Throwable $th) {

            return 0;
        }
    }
    public function deletevariation(Request $request)
    {
        $checkvariationcount = Variation::where('item_id', $request->item_id)->count();
        if ($checkvariationcount > 1) {
            $UpdateDetails = Variation::where('id', $request->id)->delete();
            if ($UpdateDetails) {
                Cart::where('variation_id', $request->id)->delete();
                return 1;
            } else {
                return 0;
            }
        } else {
            return 2;
        }
    }
    public function destroyimage(Request $request)
    {
        $getitemimages = ItemImages::where('item_id', $request->item_id)->count();
        if ($getitemimages > 1) {
            $itemimage = ItemImages::where('id', $request->id)->delete();
            if ($itemimage) {
                return 1;
            } else {
                return 0;
            }
        } else {
            return 2;
        }
    }
    public function featured(Request $request)
    {
        $updatedata = Item::where('id', $request->id)->update(['is_featured' => $request->status]);
        if ($updatedata) {
            return 1;
        } else {
            return 0;
        }
    }
    public function subcategories(Request $request)
    {
        $data = Subcategory::where('cat_id', $request->id)->orderBy('reorder_id')->where('is_available', 1)->where('is_deleted', 2)->get();
        return response()->json(['status' => 1, 'message' => trans('messages.success'), 'data' => $data], 200);
    }


    public function getProductVariantsPossibilities(Request $request, $item_id = 0)
    {
        $variant_edit = $request->variant_edit;

        if (!empty($variant_edit) && $variant_edit == 'edit') {
            $variant_option123 = json_decode($request->hiddenVariantOptions, true);
            foreach ($variant_option123 as $key => $value) {
                $new_key = array_search($value['variant_name'], array_column($request->variant_edt, 'variant_name'));
                if (!empty($request->variant_edt[$new_key]['variant_options'])) {
                    $new_val = explode('|', $request->variant_edt[$new_key]['variant_options']);
                    $variant_option123[$key]['variant_options'] = array_merge($variant_option123[$key]['variant_options'], $new_val);
                }
            }
            $request->hiddenVariantOptions = json_encode($variant_option123);
        }

        $variant_name = $request->variant_name;
        $variant_options = $request->variant_options;
        $hiddenVariantOptions = $request->hiddenVariantOptions;
        $hiddenVariantOptions = json_decode($hiddenVariantOptions, true);
        $result = [
            'hiddenVariantOptions' => json_encode($hiddenVariantOptions),
            'message' => trans('messages.variant_attribute_exist'),
        ];
        if (!empty($hiddenVariantOptions)) {
            foreach ($hiddenVariantOptions as $key => $value) {
                if (in_array($request->variant_name, $hiddenVariantOptions[$key])) {
                    return response()->json($result);
                }
            }
        }
        $variants = [
            [
                'variant_name' => $variant_name,
                'variant_options' => explode('|', $variant_options),
            ],
        ];
        if (empty($variant_edit) && $variant_edit != 'edit') {
            $hiddenVariantOptions = array_merge($hiddenVariantOptions, $variants);
        }
        $hiddenVariantOptions = array_map("unserialize", array_unique(array_map("serialize", $hiddenVariantOptions)));
        $optionArray = $variantArray = [];
        foreach ($hiddenVariantOptions as $variant) {
            $variantArray[] = $variant['variant_name'];
            $optionArray[] = $variant['variant_options'];
        }
        $possibilities = Item::possibleVariants($optionArray);
        $variantArray = array_unique($variantArray);
        if (!empty($variant_edit) && $variant_edit == 'edit') {
            $varitantHTML = view('admin.item.variants.edit_list', compact('possibilities', 'variantArray', 'item_id'))->render();
        } else {
            $varitantHTML = view('admin.item.variants.list', compact('possibilities', 'variantArray'))->render();
        }
        $result = [
            'status' => false,
            'hiddenVariantOptions' => json_encode($hiddenVariantOptions),
            'varitantHTML' => $varitantHTML,
        ];
        return response()->json($result);
    }

    public function productVariantsEdit(Request $request, $item_id)
    {

        $product = Item::where('id', $item_id)->first();
        $productVariantOption = json_decode($product->variants_json, true);
        if (empty($productVariantOption)) {
            return view('admin.item.variants.create')->render();
        } else {
            return view('admin.item.variants.edit', compact('product', 'productVariantOption', 'item_id'))->render();
        }
    }

    public function delete_review(Request $request)
    {
        $ratting = Ratting::where('id', $request->id)->first();
        $ratting->delete();
        return redirect()->back()->with('success', trans('messages.success'));
    }
    public function reorder_image(Request $request)
    {


        $getproducts = ItemImages::where('item_id', $request->item_id)->get();
        $arr = explode('|', $request->input('ids'));
        foreach ($arr as $sortOrder => $id) {
            if ($id != "" && $id != null) {
                $menu = ItemImages::find($id);
                $menu->reorder_id = $sortOrder;
                $menu->save();
            }
        }

        return response()->json(['status' => 1, 'msg' => trans('messages.success')], 200);
    }
    public function delete_extras(Request $request)
    {
        $deletedata = Extra::where('id', $request->id)->delete();
        if ($deletedata) {
            return redirect()->back()->with('success', trans('messages.success'));
        } else {
            return redirect()->back()->with('error', trans('messages.wrong'));
        }
    }
}