import { ImageResult, PlatformService } from "../PlatformService";
import { logger } from "../../utils/logger";

export class WebPlatformService implements PlatformService {
  async readFile(path: string): Promise<string> {
    throw new Error("File system access not available in web platform");
  }

  async writeFile(path: string, content: string): Promise<void> {
    throw new Error("File system access not available in web platform");
  }

  async deleteFile(path: string): Promise<void> {
    throw new Error("File system access not available in web platform");
  }

  async listFiles(directory: string): Promise<string[]> {
    throw new Error("File system access not available in web platform");
  }

  async takePicture(): Promise<ImageResult> {
    return new Promise((resolve, reject) => {
      const input = document.createElement("input");
      input.type = "file";
      input.accept = "image/*";
      input.capture = "environment";

      input.onchange = async (e) => {
        const file = (e.target as HTMLInputElement).files?.[0];
        if (file) {
          try {
            const blob = await this.processImageFile(file);
            resolve({
              blob,
              fileName: file.name || "photo.jpg"
            });
          } catch (error) {
            logger.error("Error processing camera image:", error);
            reject(new Error("Failed to process camera image"));
          }
        } else {
          reject(new Error("No image captured"));
        }
      };

      input.click();
    });
  }

  async pickImage(): Promise<ImageResult> {
    return new Promise((resolve, reject) => {
      const input = document.createElement("input");
      input.type = "file";
      input.accept = "image/*";

      input.onchange = async (e) => {
        const file = (e.target as HTMLInputElement).files?.[0];
        if (file) {
          try {
            const blob = await this.processImageFile(file);
            resolve({
              blob,
              fileName: file.name || "photo.jpg"
            });
          } catch (error) {
            logger.error("Error processing picked image:", error);
            reject(new Error("Failed to process picked image"));
          }
        } else {
          reject(new Error("No image selected"));
        }
      };

      input.click();
    });
  }

  private async processImageFile(file: File): Promise<Blob> {
    return new Promise((resolve, reject) => {
      const reader = new FileReader();
      reader.onload = (event) => {
        const dataUrl = event.target?.result as string;
        // Convert to blob to ensure consistent format
        fetch(dataUrl)
          .then(res => res.blob())
          .then(blob => resolve(blob))
          .catch(error => {
            logger.error("Error converting data URL to blob:", error);
            reject(error);
          });
      };
      reader.onerror = (error) => {
        logger.error("Error reading file:", error);
        reject(error);
      };
      reader.readAsDataURL(file);
    });
  }

  isCapacitor(): boolean {
    return false;
  }

  isElectron(): boolean {
    return false;
  }

  isPyWebView(): boolean {
    return false;
  }

  isWeb(): boolean {
    return true;
  }

  async handleDeepLink(url: string): Promise<void> {
    // Web platform can handle deep links through URL parameters
    return Promise.resolve();
  }
}