<?php

namespace Modules\Internal\Http\Controllers\Api;

use App\Exceptions\ImportRowException;
use App\Models\Corporate;
use App\Models\Member;
use Box\Spout\Reader\Common\Creator\ReaderEntityFactory;
use Box\Spout\Writer\Common\Creator\WriterEntityFactory;
use Box\Spout\Common\Entity\Row;
use Illuminate\Contracts\Support\Renderable;
use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
use Illuminate\Support\Facades\Storage;
use Modules\Internal\Services\MemberEnrollmentService;

class MemberController extends Controller
{
    public function __construct(MemberEnrollmentService $memberEnrollmentService)
    {
        $this->memberEnrollmentService = $memberEnrollmentService;
    }
    /**
     * Display a listing of the resource.
     * @return Renderable
     */
    public function index(Request $request, $corporate_id)
    {
        $benefits = Member::query()
                    ->filter($request->all())
                // ->where('corporate_id', $corporate_id)
                    ->whereHas('employeds', function ($employeds) use ($corporate_id) {
                        $employeds->where('corporate_id', $corporate_id);
                    })
                    ->with([
                        'employeds', 
                        'currentPolicy' => function ($policy) use ($corporate_id) {
                            $policy->whereHas('corporatePolicy', function($corporatePolicy) use ($corporate_id) {
                                $corporatePolicy->where('corporate_id', $corporate_id);
                            });
                        }
                    ])
                    ->paginate()
                    ->appends($request->all());
        
        return $benefits;
    }

    /**
     * Show the form for creating a new resource.
     * @return Renderable
     */
    public function create()
    {
        return view('internal::create');
    }

    /**
     * Store a newly created resource in storage.
     * @param Request $request
     * @return Renderable
     */
    public function store(Request $request)
    {
        //
    }

    /**
     * Show the specified resource.
     * @param int $id
     * @return Renderable
     */
    public function show($id)
    {
        return view('internal::show');
    }

    /**
     * Show the form for editing the specified resource.
     * @param int $id
     * @return Renderable
     */
    public function edit($id)
    {
        return view('internal::edit');
    }

    /**
     * Update the specified resource in storage.
     * @param Request $request
     * @param int $id
     * @return Renderable
     */
    public function update(Request $request, $id)
    {
        //
    }

    /**
     * Remove the specified resource from storage.
     * @param int $id
     * @return Renderable
     */
    public function destroy($id)
    {
        //
    }


    public function import(Request $request, $corporate_id)
    {
        $request->validate([
            'file' => 'required|file|mimes:xls,xlsx,csv,txt',
        ]); 
        $corporate = Corporate::findOrFail($corporate_id)->load('currentPolicy');
        
        $file_name = now()->getPreciseTimestamp(3).'-'.$request->file('file')->getClientOriginalName();
        $file = $request->file('file')->storeAs('temp', $file_name);

        $reader = ReaderEntityFactory::createReaderFromFile(Storage::path('temp/'.$file_name));
        $reader->open(Storage::path('temp/'.$file_name));
        
        $writer = WriterEntityFactory::createXLSXWriter();
        $writer->openToFile(Storage::disk('public')->path('temp/result-'.$file_name));

        $headers_map_to_table_fields = Member::$doc_headers_to_field_map;

        // Write Header to File
        $result_headers = array_keys($headers_map_to_table_fields);
        array_push($result_headers, 'Ingestion Status');
        $singleRow = WriterEntityFactory::createRow($this->memberEnrollmentService->makeResultRow($result_headers));
        $writer->addRow($singleRow);

        $imported_member_data = 0;
        $failed_member_data = [];
        foreach ($reader->getSheetIterator() as $sheet) {
            $doc_headers_indexes = [];
            foreach ($sheet->getRowIterator() as $index => $row) {
                if ($index == 1) { // First Row Must be Header
                    foreach ($row->getCells() as $index => $cell) {
                        // Clear up the string and remove all spaces
                        $title = $cell->getValue();
                        $title = preg_replace( "/\r|\n/", " ", $title );
                        $title = preg_replace('/\xc2\xa0/', " ", $title );
                        $title = rtrim($title);
                        $title = ltrim($title);
                        $doc_headers_indexes[$index] = $title;
                    }
                } else { // Next Row Should be Data
                    $new_member_data = [];
                    foreach ($row->getCells() as $header_index => $cell) {
                        if (isset($headers_map_to_table_fields[$doc_headers_indexes[$header_index]])) {
                            $new_member_data[$headers_map_to_table_fields[$doc_headers_indexes[$header_index]]] = $cell->getValue();
                        }
                    }

                    try {
                        $rowResponse = $this->memberEnrollmentService->handleImportRow($corporate, $new_member_data);
                        
                        // Write Success Result to File
                        array_push($new_member_data, 'SUCCESS');
                        $singleRow = WriterEntityFactory::createRow($this->memberEnrollmentService->makeResultRow($new_member_data));
                        $writer->addRow($singleRow);
                        $imported_member_data++;
                    } catch (ImportRowException $e) {
                        // Write Data Validation Error to File
                        array_push($new_member_data, $e->getMessage());
                        $singleRow = WriterEntityFactory::createRow($this->memberEnrollmentService->makeResultRow($new_member_data));
                        $writer->addRow($singleRow);
                        $failed_member_data[] = ['row_number' => $index, 'error' => $e->getMessage()];
                    } catch (\Exception $e) {
                        // Write Server Error to File
                        array_push($new_member_data, "Server Error");
                        $singleRow = WriterEntityFactory::createRow($this->memberEnrollmentService->makeResultRow($new_member_data));
                        $writer->addRow($singleRow);
                        $failed_member_data[] = ['row_number' => $index, 'error' => $e->getMessage()];
                    }
                }

            }
            
            break; //only read first sheet
        }
        $reader->close();
        $writer->close();
        Storage::delete('temp/'.$file_name);
        // throw(404);

        return [
            'total_success_row' => $imported_member_data,
            'total_failed_row' => count($failed_member_data),
            'failed_row' => $failed_member_data,
            'result_file' => [
                'url' => Storage::disk('public')->url('temp/result-'.$file_name),
                'name' => 'result-'.$file_name,
            ]
        ];
    }
}