<?php

namespace App\Http\Controllers;


use Illuminate\Support\Facades\Auth;
use Illuminate\Database\Schema\Blueprint; 
use Illuminate\Support\Facades\DB;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;
use App\Contents;
use App\Types;
use App\Fields;
use App\User;
use Carbon\Carbon;
use App\DevExtreme\Utils;
use App\DevExtreme\FilterHelper;
use App\DevExtreme\DbSet;

use Illuminate\Auth\Events\Registered;
use Maatwebsite\Excel\Facades\Excel;
use App\Imports\ImportExcel;
use App\Exports\ExportExcel;
use Illuminate\Support\Facades\Artisan;
use Cache;
use Illuminate\Support\Facades\Storage;
use App\Models\ColumnComment;
use Illuminate\Support\Facades\Session;
use Illuminate\Support\Facades\Log;
use App\Jobs\ExecuteSaveTriggerJob;

class AdminController extends Controller
{
	private $currentTable;

	public function __construct()
	{
		$this->middleware('auth');
	}

	/**
	 * Önbelleğe alınmış dashboard sayfasını görüntüler
	 * Eğer önbellek dosyası yoksa gerçek zamanlı oluşturur
	 */
	public function cachedDashboard()
	{
		if (Storage::exists('cache/dashboard.blade.php')) {
			$dashboardContent = Storage::get('cache/dashboard.blade.php');
			$lastUpdated = Storage::exists('cache/dashboard_last_updated.txt') 
				? Storage::get('cache/dashboard_last_updated.txt') 
				: date('Y-m-d H:i:s');
				
			return view('admin.dashboard.index', [
				'dashboardContent' => $dashboardContent,
				'lastUpdated' => $lastUpdated
			]);
		} else {
			// Önbellek bulunamadı, cron dosyasını çalıştır
			$dashboardContent = view('admin.dashboard.module.dashboard')->render();
			return view('admin.dashboard.index', [
				'dashboardContent' => $dashboardContent,
				'lastUpdated' => date('Y-m-d H:i:s') . ' (cache not found)'
			]);
		}
	}

	public function importStatus() {
		$id = session('import');
		return response([
			'started' => filled(cache("start_date_$id")),
			'finished' => filled(cache("end_date_$id")),
			'current_row' => (int) cache("current_row_$id"),
			'total_rows' => (int) cache("total_rows_$id"),
		]);
		
	}

    public function logout() {
		Auth::logout();
		Session::forget('cached_user');
		return redirect('login');
	}
    
    public function action2(string $action="",string $type ="") {
		if($type=="types") {
			$types = new Types;
			$types->title = "";
			$types->slug = "";
			$types->save();
			return back();		
					
			
		}
	}
    public function action(string $type="",string $id="",string $action ="") {
		$this->middleware('auth');
		if($type=="contents") {
			switch($action) {
				case "add" : 
					$c =  Contents::where("slug",$id)->first();			
					$content = new Contents;
					$content->title = "";
					$content->slug = rand(1111111,99999999);
					$content->tkid = json_encode(Contents::getTree($id));
					$content->breadcrumb = Contents::getBreadcrumbs($id,"{title} / ");
					if(isset($c->type)) {
						$content->type = $c->type;
					}
					
					$content->kid = $id;
					$content->save();
					return redirect("admin/$type/$id");
				break;
				case "delete":		
					$content = Contents::where('slug', $id)->orWhere("id",$id)->delete();
					return back();
				break;
				
			}	
		}
		if($type=="types") {
			switch($action) {
				
				case "delete":		
					$content = Types::where('id', $id)->delete();
					return back();
				break;
				
			}
		}
		
		
	}
	public function new(string $type="") {
		$this->middleware('auth');
		$contents = Contents::where("kid","main")
		->orderBy("s","ASC")
		->get(); // tüm içeriklerdeki ana içerikler gelecek
		$types = Types::orderBy("id", "DESC")->get(); // tüm tipler
		$var = [
			'type'	=> $type,
			'contents'	=> $contents,
			"types" 	=> $types
		];
		try {    
			return view("admin/new/$type",$var);
		} catch (\Exception $e) {
			return abort(404);
		}
	}

	public function exportExcel(Request $request, string $tableName, string $fileName="") {
		

		if($fileName=="") {
			$fileName = $tableName;
		}
		if($request->filter) {
			dd($request->filter);
		}
		$columnNames = [];
		if($request->columns) {
			$columnNames = $request->columns;
		}

		if(!getesit("module","")) {
			$fileName = get("module");
		}

		$excel = new ExportExcel($tableName, $columnNames);
		$response = Excel::download($excel, $fileName . '.xlsx');
		ob_end_clean();
		return $response;
	}

	public function importExcel(Request $request, string $tableName) {

		$id = now()->unix();
    	session([ 'import' => $id ]);

		if(!is_null($request->file('excel-file'))) {
			Excel::queueImport(new ImportExcel($tableName, $id),
				$request->file('excel-file')->store('files'));
			
		} 

		
	}

	public function truncateTable(Request $request, string $tableName) {
		$u = u();
		if($u->level == "Admin") {
			$query =  db($tableName);
			if($tableName=="users") {
				$query = $query->where(function($q) {
					$q->orWhereNull("permissions");
					$q->orWhereNull("email");
					$q->orWhereNull("recover");
					
				});
				
				$jobDesc = db("job_descriptions")->get()->pluck("title")->toArray();
				$jobDesc[] = null;
				$query = $query->whereIn("level", $jobDesc)->delete();
			} else {
				$query->truncate();
			} 
			Artisan::call('cache:clear');
		}
		
		
		return redirect()->back();
	}

	public function delete(string $tableName, int $id) {
		$query = db($tableName);
		if($tableName == "users") {
			$query = $query->where(function($q) {
				$q->orWhereNull("permissions");
				$q->orWhereNull("email");
				$q->orWhereNull("recover");
				
			});
			
			$jobDesc = db("job_descriptions")->get()->pluck("title")->toArray();
			$jobDesc[] = null;
			$query = $query->whereIn("level", $jobDesc);
		}
		echo $query->where("id", $id)->delete();
	}

	public function exceptionFields($filterColumn, $filterValue) {
		if($filterColumn == "naks_id") {
			$pattern = '/\[(.*?)\]/';
			if (preg_match($pattern, $filterValue, $matches)) {
				$result = $matches[1];
				return $result;
			} else {
				return $filterValue;
			}
		} elseif($filterColumn == "short_number-certificate_no") {
			dd($filterColumn);
		} else {
			return $filterValue;
		}
	}

	public function responseJSON($data) {
		return response()->json(
			($data), 
			200, 
			[
				'Content-Type' => 'application/json;charset=UTF-8', 
				'Charset' => 'utf-8'
			],
        	JSON_UNESCAPED_UNICODE
	);
	}

	public function autocompleteType(string $type) {
		
		$rowData = json_decode(get("row"));

		if(is_null($rowData))
		{
			$rowData = (object) request()->all();
		}

		if(getisset('$filter')) {
			$text = get('$filter');
			$pattern = "/'([^']+)'/";
			if (preg_match($pattern, $text, $matches)) {
				$substring = $matches[1]; 
			//	echo $substring; 
				$_GET['value'] = $substring;
			}
		}	
		if(isset($rowData->naks_technology)) {
			$naksTechDatas = explode(" + ", $rowData->naks_technology);
			$certificateNo = [];
			foreach($naksTechDatas AS $naksTechData) {
				$certificateNo[] = explode("-", $naksTechData)[2];
			}
		}
		$type = str_replace("*", "/", $type);
		include(base_path("app/Http/Controllers/AutoCompleteType/$type.php"));
		return $this->responseJSON($response);

		
	}

	public function autocomplete(string $tableName, string $columnName) {
		$query =  db($tableName);
		
		if(getisset('$filter')) {
			$text = get('$filter');
			$pattern = "/'([^']+)'/";
			if (preg_match($pattern, $text, $matches)) {
				$substring = $matches[1]; 
			//	echo $substring; 
				$_GET['value'] = $substring;
			}
		}	

		if(getisset("filter")) {
			$filter = json_decode(get("filter"), true);
			foreach($filter AS $filterColumn => $filterValue) {
				$filterValue = $this->exceptionFields($filterColumn, $filterValue);
				$query = $query->where($filterColumn, $filterValue);
			}
		}

		if(getisset("filter_multi")) {
			$filter = json_decode(get("filter_multi"), true);

			foreach($filter AS $filterColumn => $filterValues) {
				$filterValues = explode(",", $filterValues);
				$query = $query->whereIn($filterColumn, $filterValue);
			}
		}
		
		
		if(!getesit("value", "")) {
			$value = get("value");
			$query = $query->where($columnName,"like","%$value%");
			
		}

		$take = 20;
		if(!getesit("take", "")) {
			$take = get("take");
		}
		$query = $query->take($take);
		
		if(!getesit("values", "")) {
			$whereInColumnName = $columnName;
			
			if(!getesit("column", "")) {
				$whereInColumnName = get("column");
			}

			$values = explode(",", get("values"));
			$query = $query->whereIn($whereInColumnName, $values);
		}

		if(!getesit("pattern", "")) {
			$columns = get_variables_from_pattern(get("pattern"));
			//dd($columns);
			$query = $query->groupBy($columns)->get($columns)->toArray();
			$result = [];
			foreach($query AS $q) {
				$pattern = get("pattern");
				foreach($columns AS $column) {
					$pattern = str_replace("{".$column."}", $q->$column, $pattern);
				}
			///	dd($pattern);
				$result[] = $pattern;
			}
			$query = $result;
		} else {
			if(!getisset("all")) {
				$query = $query->select($columnName);
				$query = $query->groupBy($columnName);
			}
			
			
			if(getisset("with-column")) {
				$query = $query->get();
			} else {
				$query = $query->pluck($columnName);
			}
			
		}

		
		return  $this->responseJSON($query);

	}

public function fuzzyAutocomplete(string $tableName, ?string $columnName = null) {
		if (empty($columnName)) {
			return $this->responseJSON([]);
		}
		
		$searchTerm = request('search', '');
		$limit = (int) request('limit', 20);

		$existingValues = [];
		try {
			$existingValues = db($tableName)
				->whereNotNull($columnName)
				->where($columnName, '!=', '')
				->distinct()
				->pluck($columnName)
				->filter()
				->values()
				->toArray();
		} catch (\Exception $e) {
			dd($e);
		}
		
		// Build values array
		$allValues = [];
		foreach ($existingValues as $value) {
			$allValues[] = [
				'value' => $value,
				'display' => $value
			];
		}
		
		if (!empty($searchTerm)) {
			$searchTerm = strtolower($searchTerm);
			$results = [];
			
			foreach ($allValues as $item) {
				$value = strtolower($item['value']);
				
				$score = 0;
				
				// Exact match (highest priority)
				if ($value === $searchTerm) {
					$score = 100;
				}
				elseif (strpos($value, $searchTerm) === 0) {
					$score = 80;
				}
				elseif (strpos($value, $searchTerm) !== false) {
					$score = 60;
				}
				else {
					$distance = levenshtein($searchTerm, substr($value, 0, strlen($searchTerm) + 2));
					if ($distance <= 2) { 
						$score = 40 - ($distance * 10);
					}
				}
				
				if ($score > 0) {
					$item['score'] = $score;
					$results[] = $item;
				}
			}
			
			usort($results, function($a, $b) {
				return $b['score'] - $a['score'];
			});
			
			$seen = [];
			$uniqueResults = [];
			foreach ($results as $item) {
				if (!in_array($item['value'], $seen)) {
					$seen[] = $item['value'];
					unset($item['score']); // Remove score from output
					$uniqueResults[] = $item;
				}
				if (count($uniqueResults) >= $limit) break;
			}
			
			return $this->responseJSON($uniqueResults);
		}
		
		$uniqueResults = array_slice($allValues, 0, $limit);
		
		return $this->responseJSON($uniqueResults);
	}

	public function linkCreator(Request $request, string $tableName, string $id) {
		
		$prefix = $tableName.$id . md5(get("data"));
		/*
		if(Cache::has($prefix)) {
			return Cache::get($prefix);
		} else {
			*/
			
			$thisData = db($tableName)->where("id", $id)->first();
			$data = j($_GET['data']);
			
			if(!is_null($thisData)) {
				$data['pattern'] = str_replace(".pdf", ".[pP][dD][fF]", $data['pattern']);
				$pattern = $data['pattern'];
				$pattern2 = $data['pattern'];
				foreach($thisData AS $listColumn => $listValue) {
					$listValue = str_replace("/", "*", $listValue);
					$listValue = str_replace(" ", "*", $listValue);
				//	$listValue = str_replace("-", "*", $listValue);
					
					if($listValue != "") {
						$pattern = str_replace("{". $listColumn ."}", $listValue, $pattern);
					}
					
					
				 }
				foreach($thisData AS $listColumn => $listValue) {
					$listValue = strtolower($listValue);
					$listValue = str_replace("/", "*", $listValue);
					$listValue = str_replace(" ", "*", $listValue);
			//		$listValue = str_replace("-", "*", $listValue);

					if($listValue != "") {
						$pattern2 = str_replace("{". $listColumn ."}", $listValue, $pattern2);
					}
					
				 }
				 
				 $fullPath = "storage/documents/" . $data['path'] . $pattern;
				 $fullPath2 = "storage/documents/" . $data['path'] . $pattern2;
				 $search = glob($fullPath, GLOB_BRACE);
	
				 if(count($search) == 0) {
					$search = glob($fullPath2);
	
				 } 
	
				 if(isset($search[0])) {
					$url = url($search[0]);
					Cache::put($prefix, $url);
					return $url;
				 } else {
					return response([], 404);
				 }
			}
		//}
		
		
	}

	public function removeJson(Request $request, string $tableName) {
		$u = u();
		$id = $request['module'];

		$okPermission = false;
		
		if(is_null($id)) 
		{
			$okPermission = true;
		} 
		elseif(isAuth($id, "write"))
		{
			$okPermission = true;
		}

		if($okPermission) {
			$oldData = db($tableName)->where("id", $request['key'])->first();

			$path = "app/Http/Controllers/DeleteTrigger/$tableName.php";
		
			if(file_exists($path)) {
				include($path);
			}
	
			return db($tableName)
			->where("id", $request['key'])
			->delete();
		} else {
			return "permission error";
		}
		
	}

	private function trimData($data) {
		$refactoringData = [];
		foreach($data AS $columnName => $columnValue) {
			if (is_null($columnValue) || $columnValue === "") {
				$refactoringData[$columnName] = null;
				continue;
			}

			// Eğer string ise trim uygula
			if (is_string($columnValue)) {
				$columnValue = trim($columnValue);
			}
			
			$columnType = table_column_type($this->currentTable, $columnName);
			$refactoringData[$columnName] = $this->dateColumnFixer($columnName, $columnValue, $columnType);
		}
		return $refactoringData;
	}

	public function saveJson(Request $request, string $tableName) {
		$this->currentTable = $tableName; // tableName'i sınıf içinde saklıyoruz
		if(!is_array($request['key'])) 
		{
			$request['key'] = ['id' => $request['key']];
		} 
	
		$saveAccept = true;

		if($saveAccept) 
		{
			$updateData = $request['values'];
			$refactoringData = $this->trimData($updateData);
			$refactoringData['updated_at'] = Carbon::now();

			$beforeData = db($tableName)->where($request['key'])->first();
			
			try {
				$result = db($tableName)
				->where($request['key'])
				->update($refactoringData);


				// Değişiklikleri ColumnComment tablosuna kaydedelim
				if($result) {
					$record_id = isset($request['key']['id']) ? $request['key']['id'] : $beforeData->id;
					
					// Her değişiklik için bir kayıt ekleyelim
					foreach($refactoringData as $column => $value) {
						// Bazı sütunları atlayalım (updated_at, created_at, deleted_at)
						if(in_array($column, ['updated_at', 'created_at', 'deleted_at'])) {
							continue;
						}
						
						// Önceki değeri alalım
						$oldValue = isset($beforeData->$column) ? $beforeData->$column : null;
						
						// Değer değişmişse kaydet
						if($oldValue != $value) {
							ColumnComment::create([
								'table_name' => $tableName,
								'record_id' => $record_id,
								'column_name' => $column,
								'comment' => 'System updated the value',
								'column_value' => $value,
								'user_id' => u()->id,
								'ip_address' => $request->ip()
							]);
							
							// Document Revision REV number changed - send notification
							if($tableName == 'document_revisions' && $column == 'revision_no' && $oldValue !== null && $oldValue !== '') {
								$drawingNo = $beforeData->drawing_no ?? 'Unknown';
								$message = sprintf(
									'Document Revision REV changed from %s to %s for Drawing %s. Please update PDF files.',
									$oldValue,
									$value,
									$drawingNo
								);
								$link = "/admin/types/document-revision?id={$record_id}";
								sendNotification('notification_document_revision_changed', $message, $link, 'Document REV Changed');
							}
						}
					}
				}
				
			} catch (\Throwable $th) {
				$result = $th->getMessage();
			}
			
			// SaveTrigger'ı asenkron olarak çalıştır
			ExecuteSaveTriggerJob::dispatch(
				$tableName,
				$request->all(),
				$request['key'],
				$request['values'] ?? null,
				$beforeData,
				"update"
			);
			
		} 
		
	}

	public function insertJson(Request $request, string $tableName) {
		$this->currentTable = $tableName; // tableName'i sınıf içinde saklıyoruz
		$data = $_POST;
		unset($data['_token']);

		$refactoringData = $this->trimData($data);
		unset($refactoringData['id']);
		$refactoringData['created_at'] = Carbon::now();

		$id = db($tableName)->insertGetId($refactoringData);
		
		if(isset($id)) {
			$refactoringData['id'] = $id;
			$request['key'] = ['id' => $id]; // Array formatında set et
			
			// Yeni eklenen kayıt için ColumnComment ekleyelim
			foreach($refactoringData as $column => $value) {
				// Bazı sütunları atlayalım
				if(in_array($column, ['created_at', 'updated_at', 'deleted_at', 'id'])) {
					continue;
				}
				
				// Null olmayan ve boş string olmayan değerler için kayıt oluştur
				if($value !== null && $value !== '') {
					ColumnComment::create([
						'table_name' => $tableName,
						'record_id' => $id,
						'column_name' => $column,
						'comment' => 'System created the record',
						'column_value' => $value,
						'user_id' => u()->id,
						'ip_address' => $request->ip()
					]);
				}
			}
			
			$beforeData = db($tableName)->where($request['key'])->first();
			
			// SaveTrigger'ı asenkron olarak çalıştır
			ExecuteSaveTriggerJob::dispatch(
				$tableName,
				$request->all(),
				$request['key'],
				$request['values'] ?? null,
				$beforeData,
				"insert"
			);
		}

		return response()->json(
				($refactoringData), 
				200, 
				[
					'Content-Type' => 'application/json;charset=UTF-8', 
					'Charset' => 'utf-8'
				],
				JSON_UNESCAPED_UNICODE
			);
		
	}

	public function dateColumnFixer($columnName, $columnValue, $columnType) {
		if($columnType == "date") {
			if($columnValue == "") {
				$columnValue = null;
			} else {
				$columnValue = preg_replace('/\(.*$/', '', $columnValue);
				$carbonTarih = Carbon::parse($columnValue);
				$columnValue = $carbonTarih->toDateString(); 

				if(rejected_date($columnValue)) {
					$columnValue = null;
				}
			}
		} else {
			//başlangıç tarafında bir tab girişi vs. varsa onu temizliyoruz
			$columnValue = str_replace('\t', '', $columnValue);
		}
		

		return $columnValue;
	}


	private function rawSQLFixer($rawSQL) {
		$replaceData = [
			"AND ()" => "",
		];
		foreach($replaceData AS $from => $to ) {
			$rawSQL = str_replace($from, $to, $rawSQL);
		}
		return $rawSQL;
	}
	private function sortColumnFixer($selector) {
		$replaceData = [
			"{" => "",
			"}" => "",
		];
		foreach($replaceData AS $from => $to ) {
			$selector = str_replace($from, $to, $selector);
		}
		return $selector;
	}

	public function tableToJson(Request $request, string $tableName) {

		$_SESSION['module'] = get("module");
		$path = "app/Http/Controllers/CustomQuery/{$_GET['module']}.php"; 
		
 		if(file_exists($path)) {
			include($path);
		} else {
			$query =  db($tableName);
		}
		
		
		$u = u();
		if($tableName == "users") {
			$jobDesc = db("job_descriptions")->get()->pluck("title")->toArray();
			$jobDesc[] = null; 
			$jobDesc[] = ""; 
			if(getesit("module","employees")) {
				$query = $query->whereIn("level", ['Welder (Subcontractor)'])->orWhereNull("level");
			}
			
			
		}
		
		if(!getisset("group")) {
			if(getisset("take")) $query = $query->take(get("take"));
			if(getisset("skip")) $query = $query->skip(get("skip"));
		}
		
		if(getisset("columns")) {
			$selectColumns = j(get("columns"));
			if(!in_array("id", $selectColumns)) {
				array_unshift($selectColumns, "id");
			}
			$query = $query->select($selectColumns);
		}
		

		if(getisset("sort")) {
			$sortColumns = j($request->sort);
			foreach($sortColumns AS $sortColumn) {
				$sortType = $sortColumn['desc'] == true ? "ASC" : "DESC";
				$sortColumn['selector'] = $this->sortColumnFixer($sortColumn['selector']);
				//dd($sortColumn);
				$query = $query->orderBy($sortColumn['selector'], $sortType);
			}
		} else {
			$query = $query->orderBy("id","DESC");
		}

		if(getisset("filter")) {

			$filterColumns = j($request->filter);
			$allFilterValues = [];
			
			$rawSQL = FilterHelper::GetSqlExprByArray($filterColumns);
			$rawSQL = $this->rawSQLFixer($rawSQL);

			$query = $query->whereRaw($rawSQL);
			/*
			if(!is_array($filterColumns[0])) {
					$allFilterValues[$filterColumns[0]][] = $filterColumns[2];
			} else {
				foreach($filterColumns AS $filterColumn) {
				
					if(is_array($filterColumn)) {
						$column = $filterColumn[0];
						foreach($filterColumn AS $subFilterColumn) {
							if(is_array($subFilterColumn)) {
								$allFilterValues[$subFilterColumn[0]][] = $subFilterColumn[2];
							} else {
								//dump($filterColumn);
								if(is_array($filterColumn[0])) {
									$allFilterValues[$filterColumn[0][0]][] = $filterColumn[0][2];
								}
								
								
							}
							
						}
	
					} else {
						//dump()
						//$allFilterValues[$filterColumn[0]][] = $filterColumn[2];
					}
				}
			}

			
			foreach($allFilterValues AS $column => $values) {
				if($column != null) {
					$query = $query->whereIn($column, $values);
				}
				
			}	
			*/
		
			
		}
		
		if(isset($_SESSION['select-columns'][$tableName])) {
			$_SESSION['select-columns'][$tableName][] = "id";
			$query->select($_SESSION['select-columns'][$tableName]);
		}
		
		if(getisset("group")) {
			$groupColumnToQuery = $this->groupColumnToQuery($request, $query);
			$query = $groupColumnToQuery['query'];
		}
		
		
		$query = $query->get();
		
		$widthColumn = false;
		if(getisset("with-column")) {
			$widthColumn = true;
		}
		
		$result = [];

		$except = [
			//'created_at',
			//'updated_at'
		];
		if($query->count()>0) {
			if(getisset("group")) {
				
				$groupColumns = j($request->group);
				$key = $groupColumnToQuery['selectorName'];
			//	$items =  $query->pluck($groupColumns[0]['selector'])->toArray();
				$run = true;
				if(getisset("skip")) {
					if(!getesit("skip", "0")) {
						$run = false;
					}
				}
				
				if($run) {

					$result['data'] = [];
					$result['data'][] = [
						'key' => null,
						'count' => 0,
					];
					$added = [];
					foreach($query AS $q) {
						$keyValue = $q->$key;
	
						if(strpos($key, "date") !== false) {
							if($q->$key != "") {
								$keyValue = date("Y/m/d", strtotime($q->$key));
								if(!in_array($keyValue, $added)) {
									$result['data'][] = [
										'key' => $keyValue,
										'count' => $q->total,
									];
									$added[] = $keyValue;
								}
							}
							
							
						} else {
							if(!in_array($keyValue, $added)) {
								$result['data'][] = [
									'key' => $keyValue,
									'items' => null,
									'count' => $q->total,
								];
								$added[] = $keyValue;
							}
							
	
						}
	
						
					}
				}
					
				
			//	$result['data']['totalCount'] = db($tableName)->count();
			} else {
				foreach($query AS $q) {
					$data = [];
					if($widthColumn) {
						foreach($except AS $e) {
							unset($q->$e);
						}
						$data = $q;
					} else {
						foreach($q AS $col => $value) {
							if(!in_array($col, $except)) {
								array_push($data, $value);
							}
							
						}
					}
					
					$result['data'][] = $data;
				}
			}
			
		} else {
			$result['data'] = [];
		}
		if(getesit("requireTotalCount", true))  {
			$result['totalCount'] = db($tableName)->count();
		}

		
		//$result['data'] = $query;

		return response()->json(
				($result), 
				200, 
				[
					'Content-Type' => 'application/json;charset=UTF-8', 
					'Charset' => 'utf-8'
				],
				JSON_UNESCAPED_UNICODE
		);

	}

	private function groupColumnToQuery(Request $request, $query) {
		$groupColumns = j($request->group);
		$selector = $groupColumns[0]['selector'];
		$selectorName = $selector;
		$query = $query
		->select(
			$selector, 
			DB::raw('count(*) as total')
			)
		->groupBy($selector);

		return [
			'query' => $query,
			'selectorName' => $selectorName,
		];
	}


	public function rowDetail(Request $request, string $tableName, string $columnName) {
		$result =  db($tableName);

		if(!getesit("order", "")) {
			$order = explode(":", get("order"));
			$result = $result->orderBy($order[0], $order[1]);
		}
		
		if(is_array($request->value)) {
			$result = $result->whereIn($columnName, $request->value)->get();
		} else {
			if(getisset("nolike")) {
				$result = $result->where($columnName, $request->value)->first();
			} else {
				$result = $result->where($columnName, "LIKE", "%" . $request->value . "%")->first();
			}
		}

		
		return response()->json(
			($result), 
			200, 
			[
				'Content-Type' => 'application/json;charset=UTF-8', 
				'Charset' => 'utf-8'
			],
        	JSON_UNESCAPED_UNICODE
	);

	}

	public function getDetail(Request $request, string $tableName, string $columnName, string $value) {
		$result =  db($tableName);

		$result = $result->where($columnName, $value)->get();

		return response()->json(
			($result), 
			200, 
			[
				'Content-Type' => 'application/json;charset=UTF-8', 
				'Charset' => 'utf-8'
			],
        	JSON_UNESCAPED_UNICODE
	);

	}


	public function create(Request $request, string $tableName) {
		$post = $request->all();
		unset($post['_token']);
		db($tableName)->insert($post);
		
		return redirect()->back();
	}

	public function default(Request $request,string $type="",string $id="" )
    {
		$this->middleware('auth');
		$p = $request -> all();
		$contents = Contents::where("kid","main")
		->orderBy("s","ASC") // s alanı sıralama alanıdır. 
		->get(); // tüm içeriklerdeki ana içerikler gelecek
		$types = Types::orderBy("id","DESC")->get(); // tüm tipler
		$alt = null;
		$fields = null;
		$content_fields = null;
		$c = null;
		$j = null;
		$breadcrumb = null;
		$ust = null;
		$q = null;
		$search_contents = null;
		$seviye = null;
		$users = null;
		if(oturumisset("miktar")) {
			$miktar = oturum("miktar");
		} else {
			$miktar = 10;
		}
		if(isset($p['m'])) {
			$miktar = $p['m'];
			oturum("miktar",$p['m']);
		} 
		switch($type) {
			case "users" : 
			
			break;
			case "search" : 
			
			  $q = $p['q'];
			
			  $searchFields = ['title','html','json','tkid','kid','type'];
			  $search_contents = Contents::where(function($query) use($request, $searchFields){
				$searchWildcard = '%' . $request->q . '%';
				foreach($searchFields as $field){
				  $query->orWhere($field, 'LIKE', $searchWildcard);
				}
			  })
			  ->get();
			break;
			//ilgili type ın ne olduğuna bakmak gerekli 
			case "types":
				$c = Types::where("slug",$id)->first();
				if(!$c) yonlendir("/admin");
				if(isset($p['q'])) {
					
				}
				$q = get("q");
				$searchFields = ['title','html','json','tkid','kid','breadcrumb'];
				$alt = Contents::where("type",$c->title) 
				->where(function($query) use($request, $searchFields){
					$searchWildcard = '%' . $request->q . '%';
					foreach($searchFields as $field){
					  $query->orWhere($field, 'LIKE', $searchWildcard);
					}
				})
				
				->orderBy("id","DESC")
				->simplePaginate($miktar);;
			break;
			case "contents":
			//content alanında çalışacak şeyler öncelikle ilgili itemin içeriği ve onun alt içerikleri
					if($id=="") $view = "index"; 
					else {
						$c = Contents::where("slug",$id)->orWhere("id",$id)->first();
						if($c->kid!="") {
							$breadcrumb = Contents::getBreadcrumbs($c->kid);
							$tree = Contents::getTree($id);
							$breadcrumb2 = Contents::getBreadcrumbs($id,"{title} / ");
						}else {
							$breadcrumb = "";
							$tree = "";
							$breadcrumb2 = "";
						}
						
						$ust = Contents::where("slug",$c->kid)->first();
						$j = @json_decode($c->json,true);
						$alt = Contents::where("kid",$id)->orWhere("kid",$c->slug)->orderBy("s","ASC")->simplePaginate($miktar);
						if($c->type!="") {
							$content_type = Types::where("title",$c->type)->first(); // content type
							$content_type = @explode(",",$content_type->fields);
						}
						if($c->tkid=="") {
							DB::table("contents")
								->where('id', $id)
								->update([
									'tkid' => json_encode($tree),
									'breadcrumb' => $breadcrumb2
									]);
							
						}
						if($c->type!="") {
							$fields = Fields::get();
							$fields = json_decode($fields,true);
							$fields2 = array();
							
							//burada ilgili içerik tipine ait alanların değerleri ve tip sistemini alıyoruz. Bunu dinamik form sisteminde kullanacağız
							foreach(@$fields AS $r) {
								if(in_array($r['title'],$content_type)) {
									$fields2[$r['title']] = array(
										"values" => explode(",",$r['values']),
										"type" => $r['input_type'] 
									);
								}
								
							}
							$fields = $fields2;
							if(isset($ct->fields)) {
								$content_fields = explode(",",$ct->fields); // içerik alanları
							}
						}
					} // if
					
							
			break;
			
			//bir içerik tipine ait olan alanların input type larının tutulduğu bir tablo bu sistem types tablosuna girilen fieldsları otomatik oluşturuyor.
			case "fields" : 
				//input_type alanı boş olanları silelim
				Fields::where('input_type', '=', '')
				->orWhereNull('input_type')
				->delete();
				
				//tekrar oluşturalım tüm alanları
				foreach($types AS $t) {
					$fields = explode(",",$t->fields);
					foreach($fields AS $r) {
						$r = trim($r);
						$c = Fields::where("title",$r)->first();
						
						if($r!="") {
							if($c == "") {
								$row = new Fields();
								$row->title = $r;
								$row->type	= $t->title;
								$row->save();	
							}
						}
					}
					
				}
				$fields = Fields::get();
			break;
			default:
				$alt = null;
				$c = null;
			break;
			
		}
		
		//eğer anasayfa geldi ise index gelmedi ise default
		if($id=="" || $id=="index") {
			$view = "index";
		} else {
			$view = "default";
		}
		
		//tüm değişkenleri bir dizi olarak aktarıyoruz gönderdiklerimiz mutlaka tanımlanmış olmalı ondan dolayı bazılarında null tanımını verdim yukarıda
		$var = [
			'q'	=> $q,
			'miktar'	=> $miktar,
			'type'	=> $type,
			'users'	=> $users,
			'seviye'	=> $seviye,
			'breadcrumb'	=> $breadcrumb,
			'search_contents'	=> $search_contents,
			'content_fields'	=> $content_fields,
			'fields'	=> $fields,
			'alt'	=> $alt,
			'id'	=> $id,
			'c'	=> $c,
			'ust'	=> $ust,
			'j'	=> $j,
			'contents'	=> $contents,
			"types" 	=> $types
		];
		//try catch hayat kurtarır. Adminde ilgili tipdeki blade lere yönlendiriir yoksa default veya indexe yönlendirir. 
		$permissions = userPermissions(); //explode(",",Auth::user()->permissions);
		$permissions2 = array();
		foreach($permissions AS $p) {
			array_push($permissions2,str_slug($p));
		}
		$permissions = $permissions2;
		
		if($type=="types") {
			$alan = $id;
		} else {
			$alan = $type;
		}
		
		
		if($alan=="" && $id!="") {
			
			return view('admin/'.$view, $var);
		} else {
			try {    
			//echo "$view $type $alan"; 
				if(($view=="index") && $type=="") {
				
					return view('admin/'.$view, $var);
				} else {
				
					if(in_array("all-privileges",$permissions)) { // Tüm yetkiler
						return view("admin/$type",$var);
					} else {
						if($id != "devextreme") 
						{
							return view("admin/$type",$var);
						} 
						else 
						{
							if(isAuth($id,"read")) {
							
								return view("admin/$type",$var);
						
							
							} else {
								return view("admin/yetki-yok",$var);
							}
						}
								
					}
						
					
				}
				
			} catch (\Exception $e) {
				
				return view('admin/'.$view, $var);
			}	
		}
		
       
    }

    /**
     * User Guide functionality for module documentation
     */
    public function userGuide($module = null)
    {
        // Tüm logic view içinde yapılıyor
        return view('admin.user-guide');
    }

    /**
     * Clone row functionality - includes table-specific logic
     */
    public function cloneRow(Request $request, string $tableName)
    {
        $u = u();
        if(!isset($u->level)) {
            echo("permission error");
            exit();
        }

        $data = j(post("data"));
        $originalId = $data['id']; // Orijinal kaydın ID'sini saklayalım
        unset($data['id']);

        // Table-specific clone logic
        $path = "app/Http/Controllers/CloneTrigger/{$tableName}.php";
        if(file_exists($path)) {
            $table = $tableName; // CloneTrigger dosyaları için $table değişkenini tanımla
            include($path);
        }

        $data['created_at'] = Carbon::now();

        try {
            // Kaydı ekleyelim ve yeni ID'yi alalım
            $newId = db($tableName)->insertGetId($data);

            if($newId) {
                // Klonlanan her alan için ColumnComment kaydı oluşturalım
                foreach($data as $column => $value) {
                    // Bazı sütunları atlayalım
                    if(in_array($column, ['created_at', 'updated_at', 'deleted_at'])) {
                        continue;
                    }
                    
                    // Null olmayan ve boş string olmayan değerler için kayıt oluştur
                    if($value !== null && $value !== '') {
                        ColumnComment::create([
                            'table_name' => $tableName,
                            'record_id' => $newId,
                            'column_name' => $column,
                            'comment' => "Cloned from record #$originalId",
                            'column_value' => $value,
                            'user_id' => Auth::id(),
                            'ip_address' => request()->ip()
                        ]);
                    }
                }
                
                // Save trigger'larını çalıştırmak için gerekli değişkenleri oluştur
                $beforeData = db($tableName)->where("id", $newId)->first();
                $request = new \Illuminate\Http\Request();
                $request['key'] = ['id' => $newId];
                $request['values'] = $data;
                $request['new_record'] = true;
                
                // SaveTrigger'ı asenkron olarak çalıştır
                $job = ExecuteSaveTriggerJob::dispatch(
                        $tableName,
                        $request->all(),
                        $request['key'],
                        $request['values'],
                        $beforeData,
                        "clone"
                    );
            }
        } catch (\Throwable $th) {
            dump($th);
            Log::error("$tableName Clone row error:" . $th->getMessage());
        }
    }

    /**
     * Get unique column values for headerFilter
     * Returns all distinct values from a specific column
     */
    public function getUniqueColumnValues(Request $request, string $tableName, string $columnName) {
        try {
            // Get unique values from column
            $uniqueValues = DB::table($tableName)
                ->select($columnName)
                ->distinct()
                ->whereNotNull($columnName)
                ->where($columnName, '!=', '')
                ->orderBy($columnName)
                ->pluck($columnName)
                ->toArray();
            
            // Check if column has empty values
            $hasEmpty = DB::table($tableName)
                ->where(function($query) use ($columnName) {
                    $query->whereNull($columnName)
                          ->orWhere($columnName, '=', '');
                })
                ->exists();
            
            // Build result array
            $result = array_map(function($value) {
                return [
                    'text' => $value,
                    'value' => $value
                ];
            }, $uniqueValues);
            
            // Add empty option if exists
            if ($hasEmpty) {
                array_unshift($result, [
                    'text' => '(Boş)',
                    'value' => null
                ]);
            }
            
            return response()->json($result);
            
        } catch (\Exception $e) {
            Log::error("Get unique column values error: " . $e->getMessage());
            return response()->json(['error' => $e->getMessage()], 500);
        }
    }
}