<?php

namespace App\Http\Controllers\Admin;

use App\Employee;
use App\Http\Resources\Admin\SeveranceCalculationHistoryResource;
use App\Http\Resources\Admin\SeverancePaymentDetailResource;
use App\Jobs\GenerateExcelMultipleReportOne;
use App\Jobs\GenerateExcelSingleReportOne;
use App\Jobs\GenerateExcelSingleReportThree;
use App\Jobs\GenerateExcelSingleReportTwo;
use App\Payout;
use App\PointTable;
use App\ReportJob;
use App\Services\EmployeeService;
use App\SeveranceCalculationHistory;
use App\SeverancePayment;
use App\Http\Controllers\Controller;
use App\Http\Resources\Admin\SeverancePaymentResource;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;
use Illuminate\Validation\Rule;
use Validator;
use Carbon\Carbon;

class SeverancePaymentController extends Controller
{
	const ITEM_PER_PAGE = 100;
	
	public function index(Request $request)
	{
		$searchParams = $request->all();
		$list = SeverancePayment::query();
		$limit = Arr::get($searchParams, 'limit', static::ITEM_PER_PAGE);
		$keyword = Arr::get($searchParams, 'keyword', '');
		$fiscalYear = Arr::get($searchParams, 'fiscal_year', '');
		$employeeId = Arr::get($searchParams, 'employee_id', '');
		$paymentStatus = Arr::get($searchParams, 'payment_status', '');
		
		if ($keyword != null && $keyword != '') {
			$list->where(function ($query) use ($keyword) {
				$query->whereHas('employee', function ($q) use ($keyword) {
					$q->where('full_name', 'LIKE', '%' . $keyword . '%')
						->orWhere('full_name_kana', 'LIKE', '%' . $keyword . '%')
						->orWhere('employee_code', 'LIKE', '%' . $keyword . '%');
				});
			});
		}
		if ($fiscalYear != null && $fiscalYear != '') {
			$endDate = $fiscalYear . '-03-31';
			$startDate = Carbon::parse($endDate)->subYears(1)->year . '-04-01';
			$list->whereBetween('calculation_date', [$startDate, $endDate]);;
		}
		if ($employeeId != null && $employeeId != '') {
			$list->where('employee_id', $employeeId);
		}
		if ($paymentStatus != null && $paymentStatus != '' && in_array($paymentStatus, [0, 1])) {
			$list->where('payment_status', $paymentStatus);
		}
		
		$list->orderBy('updated_at', 'desc')->orderBy('id', 'desc');
		
		return SeverancePaymentResource::collection($list->paginate($limit));
	}
	
	public function all()
	{
		return SeverancePaymentResource::collection(
			SeverancePayment::select('*')
				->orderBy('id', 'desc')
				->get()
		);
	}
	
	public function show($id = 0)
	{
		$severancePayment = SeverancePayment::findOrFail($id);
		
		return new SeverancePaymentDetailResource($severancePayment);
	}
	
	public function store(Request $request)
	{
		$validator = Validator::make($request->all(), [
			'id'              => ['required', 'exists:severance_calculation_histories,id'],
			'employee_id'     => ['required', 'exists:employees,id'],
			'history_code'    => ['required'],
			'year'            => ['required', 'numeric', 'min:0'],
			'tenure_points'   => ['required', 'numeric', 'min:0'],
			'level_points'    => ['required', 'numeric', 'min:0'],
			'position_points' => ['required', 'numeric', 'min:0'],
		]);
		
		if ($validator->fails()) {
			return response()->json(['errors' => $validator->errors()], 403);
		}
		
		$params = $request->all();
		
		$history = SeveranceCalculationHistory::where('id', $params['id'])->first();
		if (!$history) {
			return response()->json([
				'status'  => 'error',
				'message' => 'History not found'
			], 200);
		}
		
		/*$tenurePoints = (float)$params['tenure_points'];
		$levelPoints = (float)$params['level_points'];
		$positionPoints = (float)$params['position_points'];
		$totalPoints = $tenurePoints + $levelPoints + $positionPoints;
		$totalAmount = $history->point_rate * $totalPoints;
		$finalAmount = $totalAmount * $history->payment_percent / 100;*/
		
		$insertData = [
			'employee_id'                => $history->employee_id,
			'calculation_date'           => $history->calculation_date,
			'tenure_year'                => $history->tenure_year,
			'tenure_points'              => $history->tenure_points,
			'level_points'               => $history->level_points,
			'position_points'            => $history->position_points,
			'tenure_transition_points'   => $history->tenure_transition_points,
			'level_transition_points'    => $history->level_transition_points,
			'position_transition_points' => $history->position_transition_points,
			'total_points'               => $history->total_points,
			'point_rate'                 => $history->point_rate,
			'tenure_amount'              => $history->tenure_amount,
			'level_amount'               => $history->level_amount,
			'position_amount'            => $history->position_amount,
			'total_amount'               => $history->total_amount,
			'payment_percent'            => $history->payment_percent,
			'final_amount'               => $history->final_amount,
			'retirement_fund_amount'     => $history->retirement_fund_amount,
			'severance_amount'           => $history->severance_amount,
			'calculation_detail'         => $history->calculation_detail,
			'payment_date'               => $params['payment_date'] ?? null,
			'payment_status'             => (isset($params['payment_status']) && $params['payment_status'] ? 1 : 0),
			'status'                     => (isset($params['status']) && $params['status'] ? 1 : 0),
			'created_by'                 => auth('api')->user()->id,
		];
		
		$severancePayment = SeverancePayment::where('employee_id', $params['employee_id'])->first();
		if ($severancePayment) {
			$severancePayment->update($insertData);
		} else {
			SeverancePayment::create($insertData);
		}
		
		$history->delete();
		
		return response()->json([
			'status'  => 'success',
			'message' => 'Severance payment updated successfully.'
		], 200);
	}
	
	public function storeMultiple(Request $request)
	{
		$validator = Validator::make($request->all(), [
			'employees' => ['required']
		]);
		
		if ($validator->fails()) {
			return response()->json(['errors' => $validator->errors()], 403);
		}
		
		$params = $request->all();
		
		if (count($params['employees']) <= 0) {
			return response()->json([
				'status'  => 'error',
				'code'    => null,
				'message' => 'Employee IDs is not valid.'
			], 200);
		}
		
		foreach ($params['employees'] as $employee) {
			$history = SeveranceCalculationHistory::where('id', $employee['id'])->first();
			if (!$history) continue;
			
			/*$tenurePoints = (float)$employee['tenure_points'];
			$levelPoints = (float)$employee['level_points'];
			$positionPoints = (float)$employee['position_points'];
			$totalPoints = $tenurePoints + $levelPoints + $positionPoints;
			$totalAmount = $history->point_rate * $totalPoints;
			$finalAmount = $totalAmount * $history->payment_percent / 100;*/
			
			$insertData = [
				'employee_id'                => $history->employee_id,
				'calculation_date'           => $history->calculation_date,
				'tenure_year'                => $history->tenure_year,
				'tenure_points'              => $history->tenure_points,
				'level_points'               => $history->level_points,
				'position_points'            => $history->position_points,
				'tenure_transition_points'   => $history->tenure_transition_points,
				'level_transition_points'    => $history->level_transition_points,
				'position_transition_points' => $history->position_transition_points,
				'total_points'               => $history->total_points,
				'point_rate'                 => $history->point_rate,
				'tenure_amount'              => $history->tenure_amount,
				'level_amount'               => $history->level_amount,
				'position_amount'            => $history->position_amount,
				'total_amount'               => $history->total_amount,
				'payment_percent'            => $history->payment_percent,
				'final_amount'               => $history->final_amount,
				'retirement_fund_amount'     => $history->retirement_fund_amount,
				'severance_amount'           => $history->severance_amount,
				'calculation_detail'         => $history->calculation_detail,
				'payment_date'               => $employee['payment_date'] ?? null,
				'payment_status'             => (isset($employee['payment_status']) && $employee['payment_status'] ? 1 : 0),
				'status'                     => (isset($employee['status']) && $employee['status'] ? 1 : 0),
				'created_by'                 => auth('api')->user()->id,
			];
			
			$severancePayment = SeverancePayment::where('employee_id', $employee['employee_id'])->first();
			if (!$severancePayment) {
				SeverancePayment::create($insertData);
			} else {
				$severancePayment->update($insertData);
			}
			
			$history->delete();
		}
		
		return response()->json([
			'status'  => 'success',
			'message' => 'Severance payment updated successfully.'
		], 200);
	}
	
	public function storeHistory(Request $request)
	{
		$validator = Validator::make($request->all(), [
			'employee_ids' => ['required']
		]);
		
		if ($validator->fails()) {
			return response()->json(['errors' => $validator->errors()], 403);
		}
		
		$params = $request->all();
		
		if (count($params['employee_ids']) <= 0) {
			return response()->json([
				'status'  => 'error',
				'code'    => null,
				'message' => 'Employee IDs is not valid.'
			], 200);
		}
		
		$code = md5(rand(1, 100000) . now());
		$fiscalYear = Carbon::now()->year;
		if (isset($params['year']) && $params['year'] != null && $params['year'] != '') {
			$fiscalYear = $params['year'];
		}
		
		SeveranceCalculationHistory::where('created_at', '<=', Carbon::now()->subHours(6))->delete();
		$employeeService = new EmployeeService();
		$payouts = Payout::select('years', 'rate')->orderBy('years')->get()->toArray();
		$pointTable = PointTable::select('years', 'points')->pluck('points', 'years')->toArray();
		$fiscalDate = $fiscalYear . "-03-31";
		
		foreach ($params['employee_ids'] as $employeeId) {
			$employee = Employee::where('id', $employeeId)->first();
			$result = $employeeService->calculateSeverancePayment($employee, $payouts, $pointTable, $fiscalYear);
			SeveranceCalculationHistory::create([
				'code'                       => $code,
				'employee_id'                => $employeeId,
				'calculation_date'           => $fiscalDate,
				'tenure_year'                => $result['tenure_year'],
				'tenure_points'              => $result['tenure_point'],
				'level_points'               => $result['level_point'],
				'position_points'            => $result['position_point'],
				'tenure_transition_points'   => $result['tenure']['transition_points'],
				'level_transition_points'    => $result['level']['transition_points'],
				'position_transition_points' => $result['position']['transition_points'],
				'total_points'               => $result['total_point'],
				'point_rate'                 => $result['point_rate'],
				'tenure_amount'              => $result['tenure_amount'],
				'level_amount'               => $result['level_amount'],
				'position_amount'            => $result['position_amount'],
				'total_amount'               => $result['total_amount'],
				'payment_percent'            => $result['payment_percent'],
				'final_amount'               => $result['final_amount'],
				'retirement_fund_amount'     => $result['retirement_fund_amount'],
				'severance_amount'           => $result['severance_amount'],
				'calculation_detail'         => $result,
				'created_by'                 => auth('api')->user()->id,
				'status'                     => 2,
				'created_at'                 => date('Y-m-d H:i:s'),
				'updated_at'                 => date('Y-m-d H:i:s'),
			]);
		}
		
		$histories = SeveranceCalculationHistory::where('code', $code)->get();
		
		return response()->json([
			'status' => 'success',
			'code'   => $code,
			'data'   => SeveranceCalculationHistoryResource::collection($histories)
		], 200);
	}
	
	public function severanceOnce(Request $request, $id)
	{
		$validator = Validator::make($request->all(), [
			'year' => ['required'],
		]);
		
		if ($validator->fails()) {
			return response()->json(['errors' => $validator->errors()], 403);
		}
		
		$params = $request->all();
		$severancePayment = SeverancePayment::findOrFail($id);
		$employee = Employee::findOrFail($severancePayment->employee_id);
		
		$employeeService = new EmployeeService();
		$payouts = Payout::select('years', 'rate')->orderBy('years')->get()->toArray();
		$pointTable = PointTable::select('years', 'points')->pluck('points', 'years')->toArray();
		$result = $employeeService->calculateSeverancePayment($employee, $payouts, $pointTable, $params['year']);
		
		return response()->json([
			'status' => 'success',
			'data'   => [
				'id'                         => $severancePayment->id,
				'employee_id'                => $employee->id,
				'calculation_date'           => $params['year'] . "-03-31",
				'tenure_year'                => $result['tenure_year'],
				'tenure_points'              => $result['tenure_point'],
				'level_points'               => $result['level_point'],
				'position_points'            => $result['position_point'],
				'tenure_transition_points'   => $result['tenure']['transition_points'],
				'level_transition_points'    => $result['level']['transition_points'],
				'position_transition_points' => $result['position']['transition_points'],
				'total_points'               => $result['total_point'],
				'point_rate'                 => $result['point_rate'],
				'tenure_amount'              => $result['tenure_amount'],
				'level_amount'               => $result['level_amount'],
				'position_amount'            => $result['position_amount'],
				'total_amount'               => $result['total_amount'],
				'payment_percent'            => $result['payment_percent'],
				'final_amount'               => $result['final_amount'],
				'retirement_fund_amount'     => $result['retirement_fund_amount'],
				'severance_amount'           => $result['severance_amount'],
				'calculation_detail'         => $result,
				'payment_date'               => $severancePayment->payment_date,
				'payment_status'             => $severancePayment->payment_status,
				'status'                     => $severancePayment->status,
			],
		], 200);
	}
	
	public function severanceSingle(Request $request, $id)
	{
		$validator = Validator::make($request->all(), [
			'year' => ['required'],
		]);
		
		if ($validator->fails()) {
			return response()->json(['errors' => $validator->errors()], 403);
		}
		
		$params = $request->all();
		$history = SeveranceCalculationHistory::findOrFail($id);
		$employeeService = new EmployeeService();
		$payouts = Payout::select('years', 'rate')->orderBy('years')->get()->toArray();
		$pointTable = PointTable::select('years', 'points')->pluck('points', 'years')->toArray();
		$result = $employeeService->calculateSeverancePayment($history->employee, $payouts, $pointTable, $params['year']);
		$this->updateSeveranceCalculationHistory($history, $params['year'], $result);
		
		return new SeveranceCalculationHistoryResource($history);
	}
	
	public function severanceMultiple(Request $request, $code)
	{
		$validator = Validator::make($request->all(), [
			'employee_ids' => ['required'],
			'year'         => ['required'],
		]);
		
		if ($validator->fails()) {
			return response()->json(['errors' => $validator->errors()], 403);
		}
		
		$params = $request->all();
		$histories = SeveranceCalculationHistory::where('code', $code)->get();
		
		$employeeService = new EmployeeService();
		$payouts = Payout::select('years', 'rate')->orderBy('years')->get()->toArray();
		$pointTable = PointTable::select('years', 'points')->pluck('points', 'years')->toArray();
		
		foreach ($histories as $history) {
			$result = $employeeService->calculateSeverancePayment($history->employee, $payouts, $pointTable, $params['year']);
			$this->updateSeveranceCalculationHistory($history, $params['year'], $result);
		}
		
		return SeveranceCalculationHistoryResource::collection($histories);
	}
	
	public function update(Request $request, $id = 0)
	{
		$validator = Validator::make($request->all(), [
			'employee_id'     => ['required', 'exists:employees,id'],
			'year'            => ['required', 'numeric', 'min:0'],
			'tenure_years'    => ['required', 'numeric', 'min:0'],
			'tenure_points'   => ['required', 'numeric', 'min:0'],
			'level_points'    => ['required', 'numeric', 'min:0'],
			'position_points' => ['required', 'numeric', 'min:0'],
			'point_rate'      => ['required', 'numeric', 'min:0'],
			'payment_percent' => ['required', 'numeric', 'min:0'],
		]);
		
		if ($validator->fails()) {
			return response()->json(['errors' => $validator->errors()], 403);
		}
		
		$severancePayment = SeverancePayment::findOrFail($id);
		
		if ($severancePayment->status === 1) {
			return response()->json([
				'errors' => 'レコードは編集不可としてマークされています。'
			], 403);
		}
		
		$params = $request->all();
		$employeeService = new EmployeeService();
		$payouts = Payout::select('years', 'rate')->orderBy('years')->get()->toArray();
		$pointTable = PointTable::select('years', 'points')->pluck('points', 'years')->toArray();
		$employee = Employee::where('id', $severancePayment->employee_id)->first();
		$result = $employeeService->calculateSeverancePayment($employee, $payouts, $pointTable, $params['year']);
		
		$tenurePoints = (float)$params['tenure_points'];
		$levelPoints = (float)$params['level_points'];
		$positionPoints = (float)$params['position_points'];
		$pointRate = (float)$result['point_rate'];
		$paymentPercent = (float)$result['payment_percent'];
		$totalPoints = $tenurePoints + $levelPoints + $positionPoints;
		// Round to 2 decimal places (round half up)
		$totalPoints = round($totalPoints, 2);
		$totalAmount = $pointRate * $totalPoints;
		$finalAmount = $totalAmount * $paymentPercent / 100;
		$severanceAmount = $finalAmount + $result['retirement_fund_amount'];
		
		$severancePayment->update([
			'employee_id'                => $employee->id,
			'calculation_date'           => $result['fiscal_date'],
			'tenure_year'                => $result['tenure_year'],
			'tenure_points'              => $params['tenure_points'],
			'level_points'               => $params['level_points'],
			'position_points'            => $params['position_points'],
			'tenure_transition_points'   => $result['tenure']['transition_points'],
			'level_transition_points'    => $result['level']['transition_points'],
			'position_transition_points' => $result['position']['transition_points'],
			'total_points'               => $totalPoints,
			'point_rate'                 => $pointRate,
			'tenure_amount'              => $result['tenure_amount'],
			'level_amount'               => $result['level_amount'],
			'position_amount'            => $result['position_amount'],
			'total_amount'               => $totalAmount,
			'payment_percent'            => $paymentPercent,
			'final_amount'               => $finalAmount,
			'retirement_fund_amount'     => $result['retirement_fund_amount'],
			'severance_amount'           => $severanceAmount,
			'calculation_detail'         => $result,
			'payment_date'               => $params['payment_date'] ?? null,
			'payment_status'             => (isset($params['payment_status']) && $params['payment_status'] ? 1 : 0),
			'status'                     => (isset($params['status']) && $params['status'] ? 1 : 0),
			'created_by'                 => auth('api')->user()->id,
		]);
		
		return response()->json([
			'status'  => 'success',
			'message' => 'Successfully updated severance payment'
		], 200);
	}
	
	public function updateHistory(Request $request, $id = 0)
	{
		$validator = Validator::make($request->all(), [
			'tenure_points'   => ['required'],
			'level_points'    => ['required'],
			'position_points' => ['required'],
		]);
		
		if ($validator->fails()) {
			return response()->json(['errors' => $validator->errors()], 403);
		}
		
		$history = SeveranceCalculationHistory::findOrFail($id);
		$params = $request->all();
		
		$tenurePoints = (float)$params['tenure_points'];
		$levelPoints = (float)$params['level_points'];
		$positionPoints = (float)$params['position_points'];
		$totalPoints = $tenurePoints + $levelPoints + $positionPoints;
		// Round to 2 decimal places (round half up)
		$totalPoints = round($totalPoints, 2);
		$totalAmount = $history->point_rate * $totalPoints;
		$finalAmount = $totalAmount * $history->payment_percent / 100;
		
		$history->update([
			'tenure_points'          => $tenurePoints,
			'level_points'           => $levelPoints,
			'position_points'        => $positionPoints,
			'total_points'           => $totalPoints,
			'tenure_amount'          => $tenurePoints * $history->point_rate,
			'level_amount'           => $levelPoints * $history->point_rate,
			'position_amount'        => $positionPoints * $history->point_rate,
			'total_amount'           => $totalAmount,
			'final_amount'           => $finalAmount,
			'severance_amount'       => $finalAmount + $history->retirement_fund_amount,
			'not_allow_edit'         => (isset($params['status']) && $params['status']) ? 1 : 0,
			'payment_status'         => (isset($params['payment_status']) && $params['payment_status']) ? 1 : 0,
			'payment_date'           => $params['payment_status'] ?? $history->payment_date,
		]);
		
		return response()->json(null, 204);
	}
	
	public function updateHistoryMultiple(Request $request)
	{
		$validator = Validator::make($request->all(), [
			'items' => ['required']
		]);
		
		if ($validator->fails()) {
			return response()->json(['errors' => $validator->errors()], 403);
		}
		
		$params = $request->all();
		foreach ($params['items'] as $item) {
			$history = SeveranceCalculationHistory::where('id', $item['id'])->first();
			if (!$history) continue;
			
			$tenurePoints = (float)$item['tenure_points'];
			$levelPoints = (float)$item['level_points'];
			$positionPoints = (float)$item['position_points'];
			$totalPoints = $tenurePoints + $levelPoints + $positionPoints;
			// Round to 2 decimal places (round half up)
			$totalPoints = round($totalPoints, 2);
			$totalAmount = $history->point_rate * $totalPoints;
			$finalAmount = $totalAmount * $history->payment_percent / 100;
			
			$history->update([
				'tenure_points'          => $tenurePoints,
				'level_points'           => $levelPoints,
				'position_points'        => $positionPoints,
				'total_points'           => $totalPoints,
				'tenure_amount'          => $tenurePoints * $history->point_rate,
				'level_amount'           => $levelPoints * $history->point_rate,
				'position_amount'        => $positionPoints * $history->point_rate,
				'total_amount'           => $totalAmount,
				'final_amount'           => $finalAmount,
				'severance_amount'       => $finalAmount + $history->retirement_fund_amount,
			]);
		}
		
		return response()->json(null, 204);
	}
	
	public function destroy($id = 0)
	{
		$severancePayment = SeverancePayment::findOrFail($id);
		$severancePayment->delete();
		
		return response()->json(null, 204);
	}
	
	public function historyDestroy($code = 0)
	{
		SeveranceCalculationHistory::where('code', $code)->delete();
		
		return response()->json(null, 204);
	}
	
	public function historyItemsDestroy(Request $request)
	{
		$validator = Validator::make($request->all(), [
			'ids' => ['required']
		]);
		
		if ($validator->fails()) {
			return response()->json(['errors' => $validator->errors()], 403);
		}
		
		$params = $request->all();
		SeveranceCalculationHistory::whereIn('id', $params['ids'])->delete();
		
		return response()->json(null, 204);
	}
	
	public function checkProgress($code)
	{
		$reportJob = ReportJob::where('code', $code)->first();
		
		if (!$reportJob || ($reportJob->status == 'failed')) {
			return response()->json([
				'status'  => 'error',
				'code'    => $code,
				'message' => 'Report job failed'
			], 200);
		}
		
		if ($reportJob->status == 'success' && $reportJob->file != null) {
			$data = SeveranceCalculationHistory::with('employee')
				->select('*')
				->where('code', $code)
				->orderBy('id')
				->get();
			
			return response()->json([
				'status'  => 'success',
				'code'    => $code,
				'message' => 'Successfully processed severance payment',
				'data'    => SeveranceCalculationHistoryResource::collection($data),
			], 200);
		}
		
		return response()->json([
			'status'  => 'pending',
			'code'    => $code,
			'message' => 'Report job is still processing'
		], 200);
	}
	
	public function singleDownload(Request $request, $id)
	{
		$validator = Validator::make($request->all(), [
			'type' => ['required', 'integer', Rule::in([1, 2, 3])]
		]);
		
		if ($validator->fails()) {
			return response()->json(['errors' => $validator->errors()], 403);
		}
		
		$params = $request->all();
		if (!in_array($params['type'], [1,2,3])) {
			return response()->json([
				'status'  => "error",
				'code'    => null,
				'message' => "Can't handle reports of type " . $params['type']
			]);
		}
		
		$severancePayment = SeverancePayment::findOrFail($id);
		$timestamp = Carbon::now()->format('YmdHis');
		$randomString = md5(rand(1000, 9999) . $timestamp);
		$reportJob = ReportJob::create([
			'code'       => $randomString,
			'type'       => 6,
			'status'     => 'pending',
			'created_at' => now(),
			'updated_at' => now()
		]);
		
		if ($params['type'] == 1) {
			GenerateExcelSingleReportOne::dispatch($reportJob, $severancePayment)->onQueue(config('queue.connections.redis.queue'));
		} else if ($params['type'] == 2) {
			GenerateExcelSingleReportTwo::dispatch($reportJob, $severancePayment)->onQueue(config('queue.connections.redis.queue'));
		} else {
			GenerateExcelSingleReportThree::dispatch($reportJob, $severancePayment)->onQueue(config('queue.connections.redis.queue'));
		}
		
		return response()->json([
			'status'  => "pending",
			'code'    => $randomString,
			'message' => "Processing to generate report"
		]);
	}
	
	private function updateSeveranceCalculationHistory(SeveranceCalculationHistory $history, $year, $result)
	{
		$history->update([
			'calculation_date'           => $year . "-03-31",
			'tenure_year'                => $result['tenure_year'],
			'tenure_points'              => $result['tenure_point'],
			'level_points'               => $result['level_point'],
			'position_points'            => $result['position_point'],
			'tenure_transition_points'   => $result['tenure']['transition_points'],
			'level_transition_points'    => $result['level']['transition_points'],
			'position_transition_points' => $result['position']['transition_points'],
			'total_points'               => $result['total_point'],
			'point_rate'                 => $result['point_rate'],
			'tenure_amount'              => $result['tenure_amount'],
			'level_amount'               => $result['level_amount'],
			'position_amount'            => $result['position_amount'],
			'total_amount'               => $result['total_amount'],
			'payment_percent'            => $result['payment_percent'],
			'final_amount'               => $result['final_amount'],
			'retirement_fund_amount'     => $result['retirement_fund_amount'],
			'severance_amount'           => $result['severance_amount'],
			'calculation_detail'         => $result,
			'status'                     => 2,
			'updated_at'                 => date('Y-m-d H:i:s'),
		]);
	}
}