<?php

namespace App\Http\Controllers\Mentalhealth;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;  
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\Auth;
use Symfony\Component\HttpFoundation\Response;
use Yajra\DataTables\DataTables;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Crypt;
use App\Models\Asrs;
use App\Models\Vnderbilt;
use App\Models\Conners;
use Carbon\Carbon;
use App\Models\bai;
use App\Models\gad7;
use App\Models\hama;
use App\Models\stai;
use App\Models\Aq;
use App\Models\cars;
use App\Models\bsds;
use App\Models\mdq;
use App\Models\ymrs;
use App\Models\Phq9;
use App\Models\Bdi_ii;
use App\Models\Ham_d;
use App\Models\Madrs;
use App\Models\Eat26_questionnaire;
use App\Models\Edeq;
use App\Models\Scoff_questionnaire;
use App\Models\Bprs;
use App\Models\Panss;
use App\Models\Saps;
use App\Models\cgi;
use App\Models\dsm5crosscutting;
use App\Models\ghq12;
use App\Models\kesslerscale;
use App\Models\mse;
use App\Models\Caps_5;
use App\Models\Pcl_5;
use App\Models\Tsq;
use App\Models\audit;
use App\Models\cage;
use App\Models\dast;
use App\Models\Bss;
use App\Models\C_ssrs;
use App\Models\Safe_t;
use App\Models\Recommendation;
use Illuminate\Support\Facades\Route;



class MentalhealthController extends Controller
{
   
   public function dashboard(){

    return view('mental.index');
   } 
   public function dashboard2(){
      return view('mental.index2');
     } 
   
   public function Asrs(){
   
      return view('mental.adhd.asrs');
   }
   public function Conners(){
   
      return view('mental.adhd.conners'); 
   }

   public function Vnderbilt(){
   
      return view('mental.adhd.vanderbilt');  
   }

   public function results(){
   
      return view('mental.results.result_1');  
   }
   public function resultShow($text){
   
      return view('mental.results.result_2', ['result_text' => $text]);  
   }

   public function formShow($text){
   
      return view('mental.allform', ['form_text' => $text]);   
   }
 


   public function resultGet($text, Request $request) {
      if ($request->ajax()) {
          // Define models dynamically
          $mentalhealth = Auth::guard('mental-health')->user(); 
          $models = [
              'asrs' => Asrs::class, 'conners' => Conners::class, 'vanderbilt' => Vnderbilt::class,
              'bai' => Bai::class, 'gad-7' => Gad7::class, 'ham-a' => Hama::class, 'stai' => Stai::class,
              'ados-2-overview' => Stai::class, 'aq' => Aq::class, 'cars' => Cars::class,    // Bipolar
              'bsds' => bsds::class,
              'mdq' => mdq::class,
              'ymrs' => ymrs::class,
          
              // Depression
              'phq-9' => Phq9::class,
              'bdi-ii' => Bdi_ii::class,
              'ham-d' => Ham_d::class,
              'madrs' => Madrs::class,
          
              // Eating Disorders
              'eat-26-questionnaire' => Eat26_questionnaire::class,
              'edeq' => Edeq::class,
              'scoff-questionnaire' => Scoff_questionnaire::class,
          
              // Psychosis & Schizophrenia
              'bprs' => Bprs::class,
              'panss' => Panss::class,
              'saps' => Saps::class,
          
              // General Psychological Distress
              'cgi' => cgi::class,
              'dsm5-cross-cutting' => dsm5crosscutting::class,
              'ghq-12' => ghq12::class,
              'kessler-scale' => kesslerscale::class,
              'mse-template' => mse::class,
          
              // PTSD & Trauma
              'caps-5' => Caps_5::class,
              'pcl-5' => Pcl_5::class,
              'tsq' => Tsq::class,
          
              // Substance Abuse
              'audit' => audit::class,
              'cage' => cage::class,
              'dast' => dast::class,
          
              // Suicidality Risk
              'bss' => Bss::class,
              'c-ssrs' => C_ssrs::class,
              'safe-t' => Safe_t::class,
          
          ];
  
          // Define result functions
          $resultFunctions = [
            // ADHD
            'asrs' => 'determineAsrsResult',
            'conners' => 'determineConnersResult',
            'vanderbilt' => 'determineVanderbiltResult',
        
            // Anxiety
            'bai' => 'determineBaiResult',
            'gad-7' => 'determineGad7Result',
            'ham-a' => 'determineHamaResult',
            'stai' => 'determineStaiResult',
        
            // Autism Spectrum
            'ados-2-overview' => 'determineAdos2Result',
            'aq' => 'determineAqResult',
            'cars' => 'determineCarsResult',
        
            // Bipolar
            'bsds' => 'determineBsdsResult',
            'mdq' => 'determineMdqResult',
            'ymrs' => 'determineYmrsResult',
        
            // Depression
            'phq-9' => 'determinePhq9Result',
            'bdi-ii' => 'determineBdiIiResult',
            'ham-d' => 'determineHamDResult',
            'madrs' => 'determineMadrsResult',
        
            // Eating Disorders
            'eat-26-questionnaire' => 'determineEat26Result',
            'edeq' => 'determineEdeqResult',
            'scoff-questionnaire' => 'determineScoffResult',
        
            // Psychosis & Schizophrenia
            'bprs' => 'determineBprsResult',
            'panss' => 'determinePanssResult',
            'saps' => 'determineSapsResult',
        
            // General Psychological Distress
            'cgi' => 'determineCgiResult',
            'dsm5-cross-cutting' => 'determineDsm5CrossCuttingResult',
            'ghq-12' => 'determineGhq12Result',
            'kessler-scale' => 'determineKesslerScaleResult',
            'mse-template' => 'determineMseTemplateResult',
        
            // PTSD & Trauma
            'caps-5' => 'determineCaps5Result',
            'pcl-5' => 'determinePcl5Result',
            'tsq' => 'determineTsqResult',
        
            // Substance Abuse
            'audit' => 'determineAuditResult',
            'cage' => 'determineCageResult',
            'dast' => 'determineDastResult',
        
            // Suicidality Risk
            'bss' => 'determineBssResult',
            'c-ssrs' => 'determineCssrsResult',
            'safe-t' => 'determineSafeTResult',
        ];
        
          if (isset($models[$text])) {
              $model = $models[$text];
              $resultFunction = $resultFunctions[$text] ?? 'determineVanderbiltModelResult';
  
              $dailyScores = $model::selectRaw('DATE(created_at) as raw_date, SUM(CAST(answer_value AS INTEGER)) as total_score')
                  ->whereRaw("answer_value ~ '^[0-9]+$'")  // Only numeric values
                  ->where('patient_id', $mentalhealth->patient_id)
                  ->groupBy('raw_date')
                  ->orderBy('raw_date', 'desc')
                  ->get()
                  ->map(fn($item) => [
                      'raw_date' => Carbon::parse($item->raw_date)->format('Y-m-d'),
                      'total_score' => $item->total_score,
                      'date' => Carbon::parse($item->raw_date)->format('M d, Y'),
                      'assessment' => ucfirst($text) . " Model",
                      'result' => $this->$resultFunction($item->total_score),
                      'text' => $text
                  ]);
  
              return DataTables::of($dailyScores)->make(true);
          }
  
          return response()->json(['message' => 'Invalid model specified'], 400);
      }
  
      // Define category views dynamically
      $categories = [
          'adhd' => ['asrs', 'conners', 'vanderbilt'],
          'anxiety' => ['bai', 'gad-7', 'ham-a', 'stai'],
          'autism_spectrum' => ['ados-2-overview', 'aq', 'cars'],
          'bipolar' => ['bsds', 'mdq', 'ymrs'],
          'depression' => ['phq-9', 'bdi-ii', 'ham-d', 'madrs'],
          'eating_disorders' => ['eat-26-questionnaire', 'edeq', 'scoff-questionnaire'],
          'psychosis_schizophrenia' => ['bprs', 'panss', 'saps'],
          'general_psychological_distress' => ['cgi', 'dsm5-cross-cutting', 'ghq-12', 'kessler-scale', 'mse-template'],
          'ptsd_trauma' => ['caps-5', 'pcl-5', 'tsq'],
          'substance_abuse' => ['audit', 'cage', 'dast'],
          'suicidality_risk' => ['bss', 'c-ssrs', 'safe-t'],
      ];
   
      foreach ($categories as $view => $tests) {
          if (in_array($text, $tests)) {
              return view("mental.results.$view.index", ['result_text' => $text]);
          }
      }
  }
   
   
  
   
  public function viewDetails($date, Request $request) {
   $text = $request->query('text'); // Get model type from query parameter

   $models = [
      // ADHD
      'asrs' => [Asrs::class, 'determineAsrsResult', 'Asrs (ADHD)'],
      'conners' => [Conners::class, 'determineConnersResult', 'Conners Model'],
      'vanderbilt' => [Vnderbilt::class, 'determineVanderbiltResult', 'Vanderbilt Model'],
  
      // Anxiety
      'bai' => [Bai::class, 'determineBaiResult', 'BAI Model'],
      'gad-7' => [Gad7::class, 'determineGad7Result', 'GAD-7 Model'],
      'ham-a' => [Hama::class, 'determineHamaResult', 'HAM-A Model'],
      'stai' => [Stai::class, 'determineStaiResult', 'STAI Model'],
  
      // Autism Spectrum
      'ados-2-overview' => [Stai::class, 'determineAdos2Result', 'ADOS-2 Overview'],
      'aq' => [Aq::class, 'determineAqResult', 'AQ Model'],
      'cars' => [Cars::class, 'determineCarsResult', 'CARS Model'],
  
      // Bipolar
      'bsds' => [Bsds::class, 'determineBsdsResult', 'BSDS Model'],
      'mdq' => [Mdq::class, 'determineMdqResult', 'MDQ Model'],
      'ymrs' => [Ymrs::class, 'determineYmrsResult', 'YMRS Model'],
  
      // Depression
      'phq-9' => [Phq9::class, 'determinePhq9Result', 'PHQ-9 Model'],
      'bdi-ii' => [Bdi_ii::class, 'determineBdiIiResult', 'BDI-II Model'],
      'ham-d' => [Ham_d::class, 'determineHamDResult', 'HAM-D Model'],
      'madrs' => [Madrs::class, 'determineMadrsResult', 'MADRS Model'],
  
      // Eating Disorders
      'eat-26-questionnaire' => [Eat26_questionnaire::class, 'determineEat26Result', 'EAT-26 Questionnaire'],
      'edeq' => [Edeq::class, 'determineEdeqResult', 'EDE-Q Model'],
      'scoff-questionnaire' => [Scoff_questionnaire::class, 'determineScoffResult', 'SCOFF Questionnaire'],
  
      // Psychosis & Schizophrenia
      'bprs' => [Bprs::class, 'determineBprsResult', 'BPRS Model'],
      'panss' => [Panss::class, 'determinePanssResult', 'PANSS Model'],
      'saps' => [Saps::class, 'determineSapsResult', 'SAPS Model'],
  
      // General Psychological Distress
      'cgi' => [Cgi::class, 'determineCgiResult', 'CGI Model'],
      'dsm5-cross-cutting' => [Dsm5crosscutting::class, 'determineDsm5CrossCuttingResult', 'DSM-5 Cross-Cutting'],
      'ghq-12' => [Ghq12::class, 'determineGhq12Result', 'GHQ-12 Model'],
      'kessler-scale' => [Kesslerscale::class, 'determineKesslerScaleResult', 'Kessler Scale Model'],
      'mse-template' => [Mse::class, 'determineMseTemplateResult', 'MSE Template'],
  
      // PTSD & Trauma
      'caps-5' => [Caps_5::class, 'determineCaps5Result', 'CAPS-5 Model'],
      'pcl-5' => [Pcl_5::class, 'determinePcl5Result', 'PCL-5 Model'],
      'tsq' => [Tsq::class, 'determineTsqResult', 'TSQ Model'],
  
      // Substance Abuse
      'audit' => [Audit::class, 'determineAuditResult', 'AUDIT Model'],
      'cage' => [Cage::class, 'determineCageResult', 'CAGE Model'],
      'dast' => [Dast::class, 'determineDastResult', 'DAST Model'],
  
      // Suicidality Risk
      'bss' => [Bss::class, 'determineBssResult', 'BSS Model'],
      'c-ssrs' => [C_ssrs::class, 'determineCssrsResult', 'C-SSRS Model'],
      'safe-t' => [Safe_t::class, 'determineSafeTResult', 'SAFE-T Model'],
  ];
      
  $mentalhealth = Auth::guard('mental-health')->user(); 
   // Default score ranges
   $defaultScoreRanges = [
       '0-9' => 'Low Risk', '10-20' => 'Moderate Risk', '21+' => 'High Risk'
   ];
   $asrsScoreRanges = [
       '0-16' => 'ADHD highly unlikely', '17-23' => 'ADHD possible', '24+' => 'ADHD highly likely'
   ];

   if (!isset($models[$text])) {
       return response()->json(['error' => 'Invalid model specified'], 400);
   }

   [$model, $resultFunction, $assessment] = $models[$text];
   $scoreRanges = ($text === 'asrs') ? $asrsScoreRanges : $defaultScoreRanges;

   // Fetch the result for the selected date
   $result = $model::selectRaw('DATE(created_at) as raw_date, 
                                SUM(CAST(answer_value AS INTEGER)) as total_score, 
                                STRING_AGG(notes, \', \') as notes')
        ->whereRaw("answer_value ~ '^[0-9]+$'") // सिर्फ numeric values 
        ->where("patient_id", $mentalhealth->patient_id)
        ->whereDate('created_at', $date)
        ->groupBy('raw_date')
        ->first();


   if (!$result) {
       return response()->json(['error' => 'No data found for this date'], 404);
   }
   $hcp = Auth::guard('hcp')->user();

   $notes = $model::whereDate('created_at', $date)
   ->where("patient_id", $mentalhealth->patient_id)
   ->orderBy('created_at', 'ASC') // सबसे पुरानी entry लें
   ->first(['notes']); // सिर्फ notes field लाएं

$existingRecommendation = $notes ? $notes->notes : null;
   return response()->json([
       'assessment' => $assessment, 
       'recommendation' => $existingRecommendation, 
       'total_score' => $result->total_score,
       'result' => $this->$resultFunction($result->total_score),
       'date' => $date, 
       'scoreRanges' => $scoreRanges,
       'hcp_name' => "Dr. {$hcp->first_name} {$hcp->last_name}",
       'text' => $text
   ]);
}
  
   
   
  private function determineAsrsResult($score) {
   if ($score >= 0 && $score <= 16) {
       return "ADHD highly unlikely";
   } elseif ($score >= 17 && $score <= 23) {
       return "ADHD possible";
   } else {
       return "ADHD highly likely";
   }
}

// Result function for AnotherModel
private function determineConnersResult($tScore) {
   if ($tScore < 55) {
       return "Average (typical levels of concern)";
   } elseif ($tScore >= 56 && $tScore <= 60) {
       return "Slightly elevated (borderline significant)";
   } elseif ($tScore >= 61 && $tScore <= 65) {
       return "Elevated (moderately atypical, possible significant problem)";
   } elseif ($tScore >= 66 && $tScore <= 70) {
       return "Very elevated (distinctly atypical, significant problem)";
   } else { // T-score > 70
       return "Very highly elevated (very atypical, significant problem)";
   }
}
 
private function determineVanderbiltResult($scores) {
   // Extract scores for each subscale
   $inattention = $scores['inattention'] ?? 0; // Sum of items 1-9
   $hyperactivity = $scores['hyperactivity'] ?? 0; // Sum of items 10-18
   $oppositional_defiant = $scores['oppositional_defiant'] ?? 0; // Sum of items 19-26
   $conduct_disorder = $scores['conduct_disorder'] ?? 0; // Sum of items 27-40
   $anxiety_depression = $scores['anxiety_depression'] ?? 0; // Sum of items 41-47
   $academic_performance = $scores['academic_performance'] ?? 0; // Sum of items 48-51
   $social_performance = $scores['social_performance'] ?? 0; // Sum of items 52-55

   // ADHD Subtypes
   $diagnosis = "";
   if ($inattention >= 12) {
       $diagnosis .= "Predominantly Inattentive ADHD, ";
   }
   if ($hyperactivity >= 12) {
       $diagnosis .= "Predominantly Hyperactive/Impulsive ADHD, ";
   }
   if ($inattention >= 12 && $hyperactivity >= 12) {
       $diagnosis .= "Combined ADHD Type, ";
   }

   // Comorbid Conditions
   if ($oppositional_defiant >= 8) {
       $diagnosis .= "Oppositional-Defiant Disorder (ODD) Suspected, ";
   }
   if ($conduct_disorder >= 6) {
       $diagnosis .= "Conduct Disorder (CD) Suspected, ";
   }
   if ($anxiety_depression >= 6) {
       $diagnosis .= "Anxiety/Depression Suspected, ";
   }

   // Impairment Check
   if ($academic_performance >= 4) {
       $diagnosis .= "Academic Impairment, ";
   }
   if ($social_performance >= 4) {
       $diagnosis .= "Social Impairment, ";
   }

   // Remove last comma and space, if any
   $diagnosis = rtrim($diagnosis, ', ');

   // Return result as a string
   return $diagnosis ?: "No ADHD or comorbid conditions detected";
}



private function determineBaiResult($score) {
   // Raw Score Interpretation (0-63 scale)
   if ($score >= 0 && $score <= 7) {
       $anxietyLevel = "Minimal anxiety";
   } elseif ($score >= 8 && $score <= 15) {
       $anxietyLevel = "Mild anxiety";
   } elseif ($score >= 16 && $score <= 25) {
       $anxietyLevel = "Moderate anxiety";
   } else { // 26-63
       $anxietyLevel = "Severe anxiety";
   }

   // T-Score Interpretation
   if ($score < 55) {
       $concernLevel = "Average (typical levels of concern)";
   } elseif ($score >= 56 && $score <= 60) {
       $concernLevel = "Slightly elevated (borderline significant)";
   } elseif ($score >= 61 && $score <= 65) {
       $concernLevel = "Elevated (moderately atypical, possible significant problem)";
   } elseif ($score >= 66 && $score <= 70) {
       $concernLevel = "Very elevated (distinctly atypical, significant problem)";
   } else { // T-score > 70
       $concernLevel = "Very highly elevated (very atypical, significant problem)";
   }

   // Return combined interpretation
   return "$anxietyLevel | $concernLevel";
}


private function determineGad7Result($score) {
   // Anxiety Level Interpretation
   if ($score >= 0 && $score <= 4) {
       $anxietyLevel = "Minimal anxiety";
   } elseif ($score >= 5 && $score <= 9) {
       $anxietyLevel = "Mild anxiety";
   } elseif ($score >= 10 && $score <= 14) {
       $anxietyLevel = "Moderate anxiety";
   } else { // 15-21
       $anxietyLevel = "Severe anxiety";
   }

   // Probable GAD Diagnosis
   $diagnosis = ($score >= 10) ? "Probable Generalized Anxiety Disorder (GAD)" : "No probable GAD diagnosis";

   // Return combined interpretation
   return "$anxietyLevel | $diagnosis";
}


private function determineHamaResult($score) {
   // Anxiety Level Interpretation
   if ($score >= 0 && $score <= 17) {
       $anxietyLevel = "Mild anxiety";
   } elseif ($score >= 18 && $score <= 24) {
       $anxietyLevel = "Mild to moderate anxiety";
   } elseif ($score >= 25 && $score <= 30) {
       $anxietyLevel = "Moderate to severe anxiety";
   } else { // Score > 30
       $anxietyLevel = "Severe anxiety";
   }

   // Return result
   return $anxietyLevel;
}


private function determineStaiResult($score) {
   // Anxiety Level Interpretation
   if ($score >= 20 && $score <= 37) {
       $anxietyLevel = "Low anxiety";
   } elseif ($score >= 38 && $score <= 44) {
       $anxietyLevel = "Moderate anxiety";
   } else { // Score 45-80
       $anxietyLevel = "High anxiety";
   }

   // Return result
   return $anxietyLevel;
}


private function determineAdos2Result($score) {
   if ($score >= 20 && $score <= 37) {
      $anxietyLevel = "Low anxiety";
  } elseif ($score >= 38 && $score <= 44) {
      $anxietyLevel = "Moderate anxiety";
  } else { // Score 45-80
      $anxietyLevel = "High anxiety";
  }

  // Return result
  return $anxietyLevel;

}

private function determineAqResult($score) {
   // AQ Score Interpretation
   if ($score >= 0 && $score <= 11) {
       $result = "Low autistic traits (most neurotypical adults score about 16.4)";
   } elseif ($score >= 12 && $score <= 21) {
       $result = "Medium/borderline autistic traits";
   } elseif ($score >= 22 && $score <= 25) {
       $result = "Above average autistic traits";
   } elseif ($score >= 26 && $score <= 31) {
       $result = "Borderline indication of ASD (very high autistic traits)";
   } else { // Score 32-50
       $result = "Indicates clinically significant levels of autistic traits";
   }

   // Return result with a disclaimer
   return $result . " - Note: A high score does not automatically mean the person has autism spectrum disorder. Formal diagnosis should be made by qualified healthcare professionals.";
}


private function determineCarsResult($score) {
   // CARS Score Interpretation
   if ($score >= 15 && $score <= 29.5) {
       $result = "Minimal to No Symptoms of ASD";
   } elseif ($score >= 30 && $score <= 36.5) {
       $result = "Mild to Moderate Symptoms of ASD";
   } else { // Score 37-60
       $result = "Severe Symptoms of ASD";
   }

   // Return the result
   return $result . " - Note: CARS is a screening tool, and a formal ASD diagnosis should be made by qualified professionals.";
}


private function determineBsdsResult($score) {
   // BSDS Score Interpretation
   if ($score >= 0 && $score <= 6) {
       $result = "Highly unlikely to be bipolar";
   } elseif ($score >= 7 && $score <= 12) {
       $result = "Low probability of bipolar disorder";
   } elseif ($score >= 13 && $score <= 19) {
       $result = "Moderate probability of bipolar disorder";
   } else { // Score 20-25
       $result = "High probability of bipolar disorder";
   }

   // Return the result
   return $result . " - Note: BSDS is a screening tool, and a formal diagnosis should be made by a qualified mental health professional.";
}


private function determineMdqResult($score) {
   // Ensure all necessary values exist in the $score array
   $part1_score = $score['part1'] ?? 0;
   $part2_response = $score['part2'] ?? false;
   $part3_response = $score['part3'] ?? '';

   // MDQ Screening Criteria
   if ($part1_score >= 7 && $part2_response === true && in_array($part3_response, ['Moderate', 'Serious'])) {
       return "Positive - Further clinical assessment for bipolar spectrum disorder is recommended.";
   } else {
       return "Negative - Does not meet MDQ criteria for bipolar spectrum disorder.";
   }
}


private function determineYmrsResult($score) {
   if ($score <= 12) {
       return "Remission / Minimal symptoms";
   } elseif ($score >= 13 && $score <= 19) {
       return "Mild mania";
   } elseif ($score >= 20 && $score <= 25) {
       return "Moderate mania";
   } elseif ($score >= 26 && $score <= 37) {
       return "Severe mania";
   } else { // Score ≥ 38
       return "Extreme mania";
   }
}


private function determinePhq9Result($score) {
   if ($score <= 4) {
       return "Minimal depression";
   } elseif ($score <= 9) {
       return "Mild depression";
   } elseif ($score <= 14) {
       return "Moderate depression";
   } elseif ($score <= 19) {
       return "Moderately severe depression";
   } else {
       return "Severe depression";
   }
}


private function determineBdiIiResult($score) {
   if ($score <= 13) {
       return "Minimal depression";
   } elseif ($score <= 19) {
       return "Mild depression";
   } elseif ($score <= 28) {
       return "Moderate depression";
   } else {
       return "Severe depression";
   }
}


private function determineHamDResult($score) {
   if ($score <= 7) {
       return "Normal";
   } elseif ($score <= 13) {
       return "Mild depression";
   } elseif ($score <= 18) {
       return "Moderate depression";
   } elseif ($score <= 22) {
       return "Severe depression";
   } else {
       return "Very severe depression";
   }
}


private function determineMadrsResult($score) {
   if ($score <= 6) {
       return "Normal/symptom absent";
   } elseif ($score <= 19) {
       return "Mild depression";
   } elseif ($score <= 34) {
       return "Moderate depression";
   } else {
       return "Severe depression";
   }
}



private function determineEat26Result($score) {
   if ($score <= 10) {
       return "Low risk of eating disorder";
   } elseif ($score <= 20) {
       return "Moderate risk, recommend further assessment";
   } else {
       return "High risk, immediate comprehensive evaluation needed";
   }
}

private function determineEdeqResult($score) {
   if ($score < 4.0) {
       return "Below clinical threshold; monitoring may be sufficient.";
   } else {
       return "Global score suggests clinically significant eating disorder risk.";
   }
}
 
private function determineScoffResult($score) {
   if ($score <= 1) {
       return "Low risk of eating disorder.";
   } else {
       return "Potential eating disorder; further assessment recommended.";
   }
}




private function determineBprsResult($score, $psychosisScore, $maniaScore, $depressionScore) {
   // Severity Interpretation
   if ($score <= 30) {
       $severity = "Mildly ill";
   } elseif ($score <= 41) {
       $severity = "Moderately ill";
   } elseif ($score <= 52) {
       $severity = "Markedly ill";
   } else {
       $severity = "Severely ill";
   }

   // Recommended Cutoff Scores for Specific Disorders
   $diagnosis = [];
   if ($psychosisScore >= 10) {
       $diagnosis[] = "Possible Psychosis";
   }
   if ($maniaScore >= 10) {
       $diagnosis[] = "Possible Mania";
   }
   if ($depressionScore >= 8) {
       $diagnosis[] = "Possible Depression";
   }

   // Construct result message
   $result = "Severity: " . $severity;
   if (!empty($diagnosis)) {
       $result .= " | Diagnoses: " . implode(", ", $diagnosis);
   }

   return $result;
}


private function determinePanssResult($score) {
   if ($score == 30) {
       return "Absent";
   } elseif ($score <= 60) {
       return "Minimal";
   } elseif ($score <= 90) {
       return "Mild";
   } elseif ($score <= 120) {
       return "Moderate";
   } elseif ($score <= 150) {
       return "Moderate-severe";
   } elseif ($score <= 180) {
       return "Severe";
   } else {
       return "Extreme";
   }
}

private function determineSapsResult($totalScore) {
   // Severity Interpretation Based on Total SAPS Score
   if ($totalScore <= 34) {
       $severity = "Minimal positive symptoms";
   } elseif ($totalScore <= 68) {
       $severity = "Mild positive symptoms";
   } elseif ($totalScore <= 102) {
       $severity = "Moderate positive symptoms";
   } elseif ($totalScore <= 136) {
       $severity = "Severe positive symptoms";
   } else {
       $severity = "Extreme positive symptoms";
   }

   return "SAPS Severity: $severity";
}

 

private function determineCgiResult($score) {
   if ($score == 1) {
       return "Therapeutic Effect: Marked | Side Effects: None";
   } elseif ($score == 2) {
       return "Therapeutic Effect: Moderate | Side Effects: Minimal";
   } elseif ($score == 3) {
       return "Therapeutic Effect: Minimal | Side Effects: Moderate";
   } elseif ($score == 4) {
       return "Therapeutic Effect: Unchanged/Worse | Side Effects: Marked";
   } else {
       return "Invalid score provided.";
   }
}


private function determineDsm5CrossCuttingResult($score) {
   if ($score == 0) {
       return "None: Not at all";
   } elseif ($score == 1) {
       return "Slight: Rare, less than a day or two";
   } elseif ($score == 2) {
       return "Mild: Several days";
   } elseif ($score == 3) {
       return "Moderate: More than half the days";
   } elseif ($score == 4) {
       return "Severe: Nearly every day";
   } else {
       return "Invalid score provided.";
   }
}


private function determineGhq12Result($score) {
   if ($score <= 12) {
       return "Typical psychological well-being";
   } elseif ($score <= 20) {
       return "Moderate psychological distress";
   } else {
       return "Severe psychological distress";
   }
}

private function determineKesslerScaleResult($score) {
   if ($score <= 19) {
       return "Likely to be well";
   } elseif ($score <= 24) {
       return "Likely to have a mild mental disorder";
   } elseif ($score <= 29) {
       return "Likely to have a moderate mental disorder";
   } else {
       return "Likely to have a severe mental disorder";
   }
}

private function determineMseTemplateResult($score) {
   return "Interpretation depends on clinician's observations and responses.";
}


private function determineCaps5Result($score) {
   return ($score >= 33) ? "Likely PTSD (Further assessment needed)" : "No significant PTSD symptoms";
}

private function determinePcl5Result($score) {
   // Severity Interpretation Based on Total Score
   if ($score <= 10) {
       $severity = "Minimal symptoms";
   } elseif ($score <= 23) {
       $severity = "Mild symptoms";
   } elseif ($score <= 35) {
       $severity = "Moderate symptoms";
   } elseif ($score <= 51) {
       $severity = "Moderate to severe symptoms";
   } else {
       $severity = "Severe symptoms";
   }

   // Probable PTSD Diagnosis Based on Cutoff
   $ptsd_diagnosis = ($score >= 31) ? "Probable PTSD" : "Unlikely PTSD";

   return "PCL-5 Severity: $severity | PTSD Diagnosis: $ptsd_diagnosis";
}

private function determineTsqResult($score) {
   if ($score >= 6) {
       return "Possible PTSD; further clinical assessment recommended.";
   } else {
       return "Unlikely PTSD; monitoring may be sufficient.";
   }
}



private function determineAuditResult($score) {
   if ($score <= 7) {
       return "Zone I: Low-risk drinking | Intervention: Alcohol education";
   } elseif ($score <= 15) {
       return "Zone II: Hazardous or harmful drinking | Intervention: Brief advice, brief intervention";
   } elseif ($score <= 19) {
       return "Zone III: High-risk drinking | Intervention: Brief intervention, brief counseling and monitoring";
   } else {
       return "Zone IV: Alcohol dependence | Intervention: Referral to specialist for diagnostic evaluation and treatment";
   }
}


private function determineCageResult($score) {
   if ($score == 0) {
       return "No risk indicated | Action: Reinforce abstinence or healthy use patterns";
   } elseif ($score == 1) {
       return "Low risk, possible risky use | Action: Brief advice, monitoring, reassessment at future visits";
   } else { // Score 2 or more
       return "High risk, probable alcohol/drug use disorder | Action: Further assessment recommended; consider referral for specialized evaluation and treatment";
   }
}


private function determineDastResult($score) {
   if ($score == 0) {
       return "No problems reported | Action: No intervention needed";
   } elseif ($score <= 2) {
       return "Low level of drug-related problems | Action: Monitor, reassess later | Brief intervention, advice, self-help materials";
   } elseif ($score <= 5) {
       return "Moderate level of drug-related problems | Action: Further investigation | Brief treatment, counseling (1-3 sessions), monitoring, possible referral";
   } else { // Score 6-10
       return "Substantial to severe level of drug-related problems | Action: Intensive assessment | Referral to specialized treatment";
   }
}



private function determineBssResult($score) {
   if ($score <= 3) {
       return "Minimal ideation";
   } elseif ($score <= 8) {
       return "Mild ideation";
   } elseif ($score <= 14) {
       return "Moderate ideation";
   } else { // Score 15+
       return "Severe ideation";
   }
}

private function determineCssrsResult($score) {
   if ($score >= 4) {
       return "High Risk: Immediate safety precautions required | Action: Psychiatric consultation, possible hospitalization, continuous observation";
   } elseif ($score == 3) {
       return "Moderate Risk: Suicidal ideation with method, without plan or intent | Action: Mental health referral within 24 hours, consider removing lethal means, create safety plan";
   } elseif ($score == 1 || $score == 2) {
       return "Low Risk: Wish to die or non-specific suicidal thoughts | Action: Outpatient mental health referral, provide crisis resource information";
   } else { // No suicidal ideation or behavior (score 0)
       return "No Risk Identified: No action needed | Action: Continue standard care";
   }
}

private function determineSafeTResult($score) {
   return "Evaluation depends on clinical interview and observations.";
} 


public function storeData(Request $request)
{
    $model = $request->route('model');

    $request->validate([
        'questionData' => 'required|json',
    ]);

    $mentalhealth = Auth::guard('mental-health')->user(); // ✅ Get authenticated user once

    try {
        // **Check if data already exists for today**
        $existingData = $model::where('patient_id', $mentalhealth->patient_id)
            ->whereDate('created_at', now()->toDateString()) // Checking today's date
            ->exists();

        if ($existingData) {
            return response()->json(['message' => 'You can submit only once per day!'], 400);
        }

        // ✅ Use `use ($mentalhealth)` to pass the authenticated user inside the map function
        $questionData = collect(json_decode($request->questionData, true))->map(function ($data) use ($mentalhealth) { 
            $hasAdditional = isset($data['additional_responses']) && !empty($data['additional_responses']);

            return [
                'patient_id'   => $mentalhealth->patient_id, // ✅ Now correctly accessible
                'question'     => $data['question'] ?? 'Unknown',
                'answer_value' => $hasAdditional 
                                    ? json_encode($data['additional_responses']) 
                                    : ($data['answer_value'] ?? '0'),
                'answer_text'  => $hasAdditional 
                                    ? json_encode($data['additional_responses']) 
                                    : ($data['answer_text'] ?? 'No Answer'),
                'created_at'   => now(),
                'updated_at'   => now(),
            ];
        });

        $model::insert($questionData->toArray());

        return response()->json(['message' => 'Data saved successfully!']);
    } catch (\Exception $e) {
        return response()->json(['message' => $e->getMessage()], 500);
    }
}


      
   //Anxiety

   public function Bai(){
   
      return view('mental.anxiety.bai');
   }
   public function Gad7(){
   
      return view('mental.anxiety.gad-7');
   }
   public function Hama(){
   
      return view('mental.anxiety.ham-a');
   }
   public function Stai(){
   
      return view('mental.anxiety.stai');
   }

//  Autism Spectrum
   public function Aq(){
   
      return view('mental.autism_spectrum.aq');
   }
   
   public function cars(){
   
      return view('mental.autism_spectrum.cars');
   }
   
   
    // bipolar

    public function bsds(){
    
      return view('mental.bipolar.bsds');
   }

   public function mdq(){
    
      return view('mental.bipolar.mdq'); 
   }

   public function ymrs(){
    
      return view('mental.bipolar.ymrs');
   }
   
   
     // depression
   public function Phq9(){
   
      return view('mental.depression.phq-9');
   }

   public function bdiIi(){
   
      return view('mental.depression.bdi-Ii');
   }

   public function hamD(){
   
      return view('mental.depression.ham-d');
   }

   public function madrs(){
   
      return view('mental.depression.madrs');
   }


   
   //  eating disorders
   public function eat26Questionnaire(){
    
      return view('mental.eating_disorders.eat-26-questionnaire');
   }

   public function Edeq(){
    
      return view('mental.eating_disorders.edeq');
   }
   public function scoffQuestionnaire(){
    
      return view('mental.eating_disorders.scoff-questionnaire');
   }
    
   
   //general_psychological_distress
   public function cgi(){
    
      return view('mental.general_psychological_distress.cgi');
   }
   public function dsm5crosscutting(){
    
      return view('mental.general_psychological_distress.dsm5-cross-cutting');
   }
   public function ghq12(){
    
      return view('mental.general_psychological_distress.ghq-12');
   }
   public function kesslerscale(){
    
      return view('mental.general_psychological_distress.kessler-scale');
   }
   public function msetemplate(){
    
      return view('mental.general_psychological_distress.mse-template');
   }

   //psychosis schizophrenia
   

   public function bprs(){
    
      return view('mental.psychosis_schizophrenia.bprs');
   }

   public function panss(){
    
      return view('mental.psychosis_schizophrenia.panss');
   }

   public function saps(){
    
      return view('mental.psychosis_schizophrenia.saps');
   }
   
   
   // ptsd trauma
 

   public function caps5(){
    
      return view('mental.ptsd_trauma.caps-5');
   }

   public function pcl5(){
    
      return view('mental.ptsd_trauma.pcl-5'); 
   }

   public function tsq(){
    
      return view('mental.ptsd_trauma.tsq');
   }
   
   
    // substance_abuse

    public function audit(){
    
      return view('mental.substance_abuse.audit');
   }

   public function cage(){
    
      return view('mental.substance_abuse.cage'); 
   }

   public function dast(){
    
      return view('mental.substance_abuse.dast');
   }
   


   // // /suicidality_risk

   public function bss(){
    
      return view('mental.suicidality_risk.bss');
   }

   public function cSsrs(){
    
      return view('mental.suicidality_risk.c-ssrs');
   }
   public function safeT(){
    
      return view('mental.suicidality_risk.safe-t');
   } 
   
   public function recommendationsStore(Request $request) {
    try {
        $validated = $request->validate([
            'notes' => 'required|string',
            'date' => 'nullable|date',
            'model' => 'nullable',
        ]);

        $models = [
            // ADHD
            'asrs' => [Asrs::class],
            'conners' => [Conners::class],
            'vanderbilt' => [Vnderbilt::class],

            // Anxiety
            'bai' => [Bai::class],
            'gad-7' => [Gad7::class],
            'stai' => [Stai::class],

            // Autism Spectrum
            'ados-2-overview' => [Stai::class],
            'aq' => [Aq::class],
            'cars' => [Cars::class],

            // Bipolar
            'bsds' => [Bsds::class],
            'mdq' => [Mdq::class],
            'ymrs' => [Ymrs::class],

            // Depression
            'phq-9' => [Phq9::class],
            'bdi-ii' => [Bdi_ii::class],
            'ham-d' => [Ham_d::class],
            'madrs' => [Madrs::class],

            // Eating Disorders
            'eat-26-questionnaire' => [Eat26_questionnaire::class],
            'edeq' => [Edeq::class],
            'scoff-questionnaire' => [Scoff_questionnaire::class],

            // Psychosis & Schizophrenia
            'bprs' => [Bprs::class],
            'panss' => [Panss::class],
            'saps' => [Saps::class],

            // General Psychological Distress
            'cgi' => [Cgi::class],
            'dsm5-cross-cutting' => [Dsm5crosscutting::class],
            'ghq-12' => [Ghq12::class],
            'kessler-scale' => [Kesslerscale::class],
            'mse-template' => [Mse::class],

            // PTSD & Trauma
            'caps-5' => [Caps_5::class],
            'pcl-5' => [Pcl_5::class],
            'tsq' => [Tsq::class],

            // Substance Abuse
            'audit' => [Audit::class],
            'cage' => [Cage::class],
            'dast' => [Dast::class],

            // Suicidality Risk
            'bss' => [Bss::class],
            'c-ssrs' => [C_ssrs::class],
            'safe-t' => [Safe_t::class],
        ];

        // Check if the model is provided
        if (!isset($validated['model']) || !isset($models[$validated['model']])) {
            return response()->json(['error' => 'Invalid model specified'], 400);
        }

        [$model] = $models[$validated['model']];

        // Fetch and update the record for the selected date
        $result = $model::whereDate('created_at', $validated['date'])->update(['notes' => $validated['notes']]);

        if (!$result) {
            return response()->json(['error' => 'No data found for this date'], 404);
        }

        return response()->json(['success' => true, 'message' => 'Recommendation saved successfully!']);

    } catch (\Illuminate\Validation\ValidationException $e) {
        return response()->json(['error' => 'Validation error', 'messages' => $e->errors()], 422);
    } catch (\Exception $e) {
        return response()->json(['error' => 'Something went wrong', 'message' => $e->getMessage()], 500);
    }
}
  
   
public function logout(Request $request)

{ 
    Auth::guard('mental-health')->logout(); 
    return redirect('/hcp/mentalhealthpatientsView');     

}


}