// src/app.ts

import express, { Application, Request, Response } from "express";

import dotenv from "dotenv";

dotenv.config();

const app: Application = express();

app.use(express.json());

app.get("/", (req: Request, res: Response) => {
  res.status(200).json({ message: "Prayer Time API running!" });
});

// ... (Middleware error handling dan rute akan ditambahkan di sini)

export default app;

// src/server.ts

import app from "./app";

const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

// src/features/prayer-times/prayer-times.service.ts

import {
  PrayerTimeCalculator,
  IPrayerTimeCalculatorConfig,
} from "@masaajid/prayer-times";

import { ICalculationInput } from "./prayer-times.types";

export class PrayerTimesService {
  /**

* Menghitung waktu sholat harian berdasarkan konfigurasi.

* Ini adalah inti dari "mesin" kalkulator kita.

*/

  public calculateDailyTimes(input: ICalculationInput) {
    const { date, latitude, longitude, method, asr, highLatitude } = input;

    // 1. Petakan input API kita ke konfigurasi library

    const config: IPrayerTimeCalculatorConfig = {
      method: method || "MWL", // Default ke MWL jika tidak dispesifikasi

      date: date,

      location: [latitude, longitude],

      timezone: input.timezone || this.detectTimezone(latitude, longitude), // Helper

      asrSchool: asr === "Hanafi" ? "Hanafi" : "Standard",

      highLatitudeRule: highLatitude || "AngleBased",
    };

    // 2. Buat instance kalkulator

    const calculator = new PrayerTimeCalculator(config);

    // 3. Lakukan kalkulasi

    const times = calculator.calculate();

    // 4. (Opsional) Format output agar lebih rapi

    return {
      fajr: times.fajr.toLocaleTimeString("en-US", { hour12: false }),

      sunrise: times.sunrise.toLocaleTimeString("en-US", { hour12: false }),

      dhuhr: times.dhuhr.toLocaleTimeString("en-US", { hour12: false }),

      asr: times.asr.toLocaleTimeString("en-US", { hour12: false }),

      maghrib: times.maghrib.toLocaleTimeString("en-US", { hour12: false }),

      isha: times.isha.toLocaleTimeString("en-US", { hour12: false }),
    };
  }

  // (Helper function sederhana, untuk produksi gunakan library seperti 'find-tz')

  private detectTimezone(lat: number, lon: number): string {
    // Implementasi deteksi zona waktu (bisa jadi kompleks)

    // Untuk saat ini, kita bisa minta user input 'timezone'

    // atau default ke 'UTC'.

    // Mari kita asumsikan 'timezone' adalah parameter wajib untuk kesederhanaan.

    // Dalam implementasi nyata, ini PENTING.

    return "Asia/Jakarta"; // Placeholder
  }

  // ... (Fungsi untuk kalender akan ditambahkan di sini)
}

// Dalam calculateDailyTimes, tambahkan logika untuk parameter kustom

if (input.fajrAngle && input.ishaAngle) {
  config.method = "Custom";

  config.customMethod = {
    fajr: input.fajrAngle,

    isha: input.ishaAngle,
  };
}

// src/features/prayer-times/prayer-times.routes.ts

import { Router } from "express";

import { query } from "express-validator";

import { PrayerTimesController } from "./prayer-times.controller";

const router = Router();

const controller = new PrayerTimesController();

// Validasi untuk endpoint /timings

const timingsValidation = [
  query("date")
    .isISO8601()
    .toDate()
    .withMessage("Invalid date format (YYYY-MM-DD)"),

  query("latitude")
    .isFloat({ min: -90, max: 90 })
    .withMessage("Invalid latitude"),

  query("longitude")
    .isFloat({ min: -180, max: 180 })
    .withMessage("Invalid longitude"),

  query("timezone").notEmpty().isString().withMessage("Timezone is required"),

  query("method").optional().isString(),

  query("asr").optional().isIn(["Standard", "Hanafi"]),
];

// Endpoint: GET /api/v1/timings?date=...&latitude=...&longitude=...

router.get("/timings", timingsValidation, controller.getDailyTimings);

// Endpoint: GET /api/v1/calendar?year=...&month=...&latitude=...

// ... (Tambahkan rute dan validasi untuk kalender)

export default router;

// src/features/prayer-times/prayer-times.controller.ts

import { Request, Response, NextFunction } from "express";

import { validationResult } from "express-validator";

import { PrayerTimesService } from "./prayer-times.service";

export class PrayerTimesController {
  private prayerTimesService = new PrayerTimesService();

  public getDailyTimings = (
    req: Request,
    res: Response,
    next: NextFunction
  ) => {
    // 1. Cek hasil validasi

    const errors = validationResult(req);

    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }

    try {
      // 2. Ambil data yang sudah divalidasi

      const input = req.query as unknown as ICalculationInput;

      // 3. Panggil service

      const timings = this.prayerTimesService.calculateDailyTimes(input);

      // 4. Kembalikan respons sukses

      res.status(200).json({
        code: 200,

        status: "OK",

        data: timings,

        params: input,
      });
    } catch (error) {
      next(error); // Lempar ke global error handler
    }
  };

  // ... (Implementasi getMonthlyCalendar)
}

// src/app.ts

// ... (setelah import dan app = express())

import prayerTimesRoutes from './features/prayer-times/prayer-times.routes';

app.use('/api/v1', prayerTimesRoutes);

// ... (sebelum export default app)

// src/features/calendar-conversion/calendar-conversion.service.ts

import { toHijri, toGregorian, HijriDate } from "@tabby_ai/hijri-converter";

export class CalendarConversionService {
  public convertGregorianToHijri(year: number, month: number, day: number) {
    const hijriDate = toHijri(year, month, day);

    return {
      date: `${hijriDate.hy}-${hijriDate.hm}-${hijriDate.hd}`,

      year: hijriDate.hy,

      month: hijriDate.hm,

      day: hijriDate.hd,

      monthName: this.getHijriMonthName(hijriDate.hm),
    };
  }

  public convertHijriToGregorian(year: number, month: number, day: number) {
    const gregDate = toGregorian(year, month, day);

    return {
      date: `${gregDate.gy}-${gregDate.gm}-${gregDate.gd}`,

      year: gregDate.gy,

      month: gregDate.gm,

      day: gregDate.gd,
    };
  }

  private getHijriMonthName(month: number): string {
    const names = [
      "Muharram",
      "Safar",
      "Rabi' al-Awwal",
      "Rabi' al-Thani",

      "Jumada al-Ula",
      "Jumada al-Akhirah",
      "Rajab",
      "Sha'ban",

      "Ramadan",
      "Shawwal",
      "Dhu al-Qi'dah",
      "Dhu al-Hijjah",
    ];

    return names[month - 1];
  }
}

// src/core/lib/cache.service.ts

import Redis from "ioredis";

export class CacheService {
  private client: Redis;

  constructor() {
    this.client = new Redis(process.env.REDIS_URL || "redis://localhost:6379");

    this.client.on("error", (err) => console.error("Redis Client Error", err));
  }

  public async get(key: string): Promise<string | null> {
    return this.client.get(key);
  }

  public async set(
    key: string,
    value: string,
    ttlSeconds: number = 3600
  ): Promise<void> {
    // 'EX' untuk set expiry dalam detik

    await this.client.set(key, value, "EX", ttlSeconds);
  }

  public async del(key: string): Promise<void> {
    await this.client.del(key);
  }
}

export const cacheService = new CacheService();

// src/features/prayer-times/prayer-times.controller.ts

import { cacheService } from '../../core/lib/cache.service';

// ... di dalam kelas PrayerTimesController

public getDailyTimings = async (req: Request, res: Response, next: NextFunction) => {

// ... (Validasi)

try {

// 1. Buat cache key yang unik berdasarkan input

const input = req.query as unknown as ICalculationInput;

// (Gunakan library 'object-hash' untuk membuat hash yang konsisten)

const cacheKey = `timings:${JSON.stringify(input)}`;

// 2. Cek di cache dulu

const cachedData = await cacheService.get(cacheKey);

if (cachedData) {

return res.status(200).json({

code: 200,

status: "OK",

fromCache: true,

data: JSON.parse(cachedData),

});

}

// 3. Jika tidak ada di cache, hitung baru

const timings = this.prayerTimesService.calculateDailyTimings(input);

// 4. Simpan ke cache (TTL 1 hari = 86400 detik)

await cacheService.set(cacheKey, JSON.stringify(timings), 86400);

// 5. Kembalikan respons

res.status(200).json({

code: 200,

status: "OK",

fromCache: false,

data: timings,

params: input

});

} catch (error) {

next(error);

}

};

// src/features/qibla/qibla.service.ts

export class QiblaService {
  private readonly KAABA_LAT = 21.4225;

  private readonly KAABA_LON = 39.8262;

  private toRadians(degrees: number): number {
    return degrees * (Math.PI / 180);
  }

  private toDegrees(radians: number): number {
    return radians * (180 / Math.PI);
  }

  public calculateQiblaDirection(latitude: number, longitude: number): number {
    const latA = this.toRadians(latitude);

    const lonA = this.toRadians(longitude);

    const latB = this.toRadians(this.KAABA_LAT);

    const lonB = this.toRadians(this.KAABA_LON);

    const deltaLon = lonB - lonA;

    const y = Math.sin(deltaLon) * Math.cos(latB);

    const x =
      Math.cos(latA) * Math.sin(latB) -
      Math.sin(latA) * Math.cos(latB) * Math.cos(deltaLon);

    const bearing = this.toDegrees(Math.atan2(y, x));

    // Normalisasi hasil agar berada dalam rentang 0-360 derajat (utara = 0°)

    return (bearing + 360) % 360;
  }
}

// src/features/qibla/qibla.service.test.ts

import { QiblaService } from "./qibla.service";

describe("QiblaService", () => {
  const service = new QiblaService();

  it("should calculate correct Qibla for Jakarta, ID", () => {
    // Lintang: -6.2088, Bujur: 106.8456

    const direction = service.calculateQiblaDirection(-6.2088, 106.8456);

    // Nilai referensi: 295.23°

    expect(direction).toBeCloseTo(295.23, 1); // Toleransi 1 desimal
  });

  it("should calculate correct Qibla for New York, USA", () => {
    // Lintang: 40.7128, Bujur: -74.0060

    const direction = service.calculateQiblaDirection(40.7128, -74.006);

    // Nilai referensi: 58.49°

    expect(direction).toBeCloseTo(58.49, 1);
  });
});

// src/features/prayer-times/prayer-times.test.ts

import request from "supertest";

import app from "../../app"; // Import aplikasi Express kita

describe("GET /api/v1/timings", () => {
  it("should return 400 Bad Request for invalid latitude", async () => {
    const res = await request(app).get(
      "/api/v1/timings?date=2024-12-20&latitude=200&longitude=106&timezone=Asia/Jakarta"
    );

    expect(res.status).toBe(400);

    expect(res.body.errors[0].msg).toContain("Invalid latitude");
  });

  it("should return 200 OK with prayer times for valid request (Jakarta)", async () => {
    const res = await request(app).get(
      "/api/v1/timings?date=2024-12-20&latitude=-6.2088&longitude=106.8456&timezone=Asia/Jakarta&method=Indonesia"
    );

    expect(res.status).toBe(200);

    expect(res.body.data).toHaveProperty("fajr");

    expect(res.body.data.fajr).toBe("04:14"); // Nilai referensi
  });
});

// src/app.ts

import helmet from "helmet";

import cors from "cors";

import rateLimit from "express-rate-limit";

// ...

app.use(helmet());

app.use(cors({ origin: "https://domain-frontend-anda.com" })); // Whitelist

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 menit

  max: 100, // 100 permintaan per IP per 15 menit
});

app.use("/api", limiter);

// ...