import { useCallback, useEffect, useRef, useState } from 'react';
import {
  addRingerListener,
  addSilentListener,
  addVolumeListener,
  enable,
  getRingerMode,
  getVolume,
  isAndroidDeviceSilent,
  removeRingerListener,
  setActive,
  setCategory,
  setMode,
  setVolume,
  showNativeVolumeUI,
  useSilentSwitch,
} from 'react-native-volume-manager';
import type {
  RingerModeType,
  RingerSilentStatus,
  VolumeResult,
} from 'react-native-volume-manager';

export interface TestResult {
  status: 'idle' | 'running' | 'success' | 'fail';
  message: string;
  details?: string;
}

type Subscription = { remove(): void };

const IDLE_RESULT: TestResult = {
  status: 'idle',
  message: '待执行',
};

function errorMessage(error: unknown): string {
  if (error instanceof Error) {
    return error.message;
  }
  return String(error);
}

function formatTimestamp(date: Date = new Date()): string {
  const twoDigits = (value: number) => String(value).padStart(2, '0');
  return [
    twoDigits(date.getHours()),
    twoDigits(date.getMinutes()),
    twoDigits(date.getSeconds()),
  ].join(':');
}

function isRingerMode(value: unknown): value is RingerModeType {
  return value === 0 || value === 1 || value === 2;
}

export function useVolumeRead() {
  const [result, setResult] = useState<TestResult>(IDLE_RESULT);

  const readVolume = useCallback(async () => {
    setResult({ status: 'running', message: '正在调用 getVolume...' });
    try {
      const value = await getVolume();
      const streams = value as VolumeResult &
        Partial<Record<'music' | 'ring' | 'system', number>>;
      const requiredStreamsValid = ['music', 'ring', 'system'].every((name) => {
        const streamValue = streams[name as 'music' | 'ring' | 'system'];
        return (
          typeof streamValue === 'number' &&
          Number.isFinite(streamValue) &&
          streamValue >= 0 &&
          streamValue <= 1
        );
      });
      if (
        typeof value?.volume !== 'number' ||
        !Number.isFinite(value.volume) ||
        value.volume < 0 ||
        value.volume > 1 ||
        !requiredStreamsValid
      ) {
        setResult({
          status: 'fail',
          message: 'getVolume 返回无效音量,或缺少 music/ring/system 归一化字段',
          details: JSON.stringify(value),
        });
        return;
      }
      setResult({
        status: 'success',
        message: `读取成功:主音量 ${value.volume.toFixed(4)}`,
        details: JSON.stringify(value, null, 2),
      });
    } catch (error) {
      setResult({
        status: 'fail',
        message: `getVolume 调用失败:${errorMessage(error)}`,
      });
    }
  }, []);

  return { result, readVolume };
}

export function useVolumeListener() {
  const [listening, setListening] = useState(false);
  const [events, setEvents] = useState<string[]>([]);
  const [result, setResult] = useState<TestResult>(IDLE_RESULT);
  const subscriptionRef = useRef<Subscription | null>(null);

  const stop = useCallback(() => {
    const subscription = subscriptionRef.current;
    if (subscription) {
      subscription.remove();
      subscriptionRef.current = null;
    }
    setListening(false);
    setResult({
      status: 'success',
      message: '音量监听已停止;后续系统音量变化不应再新增事件',
    });
  }, []);

  const start = useCallback(() => {
    if (subscriptionRef.current) {
      setResult({
        status: 'success',
        message: '音量监听已经开启,未重复注册',
      });
      return;
    }
    try {
      const subscription = addVolumeListener((event: VolumeResult) => {
        const valid =
          typeof event?.volume === 'number' &&
          Number.isFinite(event.volume) &&
          event.volume >= 0 &&
          event.volume <= 1 &&
          typeof event.type === 'string' &&
          ['music', 'call', 'system', 'ring', 'alarm', 'notification'].includes(
            event.type
          );
        const text = `${formatTimestamp()} ${JSON.stringify(event)}`;
        setEvents((current) => [text, ...current].slice(0, 20));
        setResult(
          valid
            ? {
                status: 'success',
                message: '收到有效的 RNVMEventVolume 事件',
                details: JSON.stringify(event),
              }
            : {
                status: 'fail',
                message: 'RNVMEventVolume 事件负载无效',
                details: JSON.stringify(event),
              }
        );
      });
      subscriptionRef.current = subscription;
      setListening(true);
      setResult({
        status: 'running',
        message: '音量监听已开启,请调节系统音量验证事件',
      });
    } catch (error) {
      setResult({
        status: 'fail',
        message: `addVolumeListener 调用失败:${errorMessage(error)}`,
      });
    }
  }, []);

  useEffect(() => {
    return () => {
      subscriptionRef.current?.remove();
      subscriptionRef.current = null;
    };
  }, []);

  return { listening, events, result, start, stop };
}

export function useRingerRead() {
  const [result, setResult] = useState<TestResult>(IDLE_RESULT);

  const read = useCallback(async () => {
    setResult({ status: 'running', message: '正在调用 getRingerMode...' });
    try {
      const mode = await getRingerMode();
      if (!isRingerMode(mode)) {
        setResult({
          status: 'fail',
          message: `getRingerMode 返回了无效模式:${String(mode)}`,
        });
        return;
      }
      setResult({
        status: 'success',
        message: `铃声模式:${mode}(0=静音,1=振动,2=正常)`,
      });
    } catch (error) {
      setResult({
        status: 'fail',
        message: `getRingerMode 调用失败:${errorMessage(error)}`,
      });
    }
  }, []);

  const readMultiple = useCallback(async (count: number) => {
    setResult({
      status: 'running',
      message: `正在连续调用 getRingerMode ${count} 次...`,
    });
    try {
      const modes: Array<RingerModeType | undefined> = [];
      for (let index = 0; index < count; index += 1) {
        modes.push(await getRingerMode());
      }
      const allValid = modes.every(isRingerMode);
      const stable = allValid && modes.every((mode) => mode === modes[0]);
      setResult({
        status: stable ? 'success' : 'fail',
        message: stable
          ? `连续 ${count} 次读取结果稳定:${modes[0]}`
          : `连续读取结果不一致或无效:${modes.join(', ')}`,
        details: JSON.stringify(modes),
      });
    } catch (error) {
      setResult({
        status: 'fail',
        message: `连续调用 getRingerMode 失败:${errorMessage(error)}`,
      });
    }
  }, []);

  return { result, read, readMultiple };
}

export function useSilentQuery() {
  const [result, setResult] = useState<TestResult>(IDLE_RESULT);

  const query = useCallback(async () => {
    setResult({
      status: 'running',
      message: '正在调用 isAndroidDeviceSilent...',
    });
    try {
      const silent = await isAndroidDeviceSilent();
      if (typeof silent !== 'boolean') {
        setResult({
          status: 'fail',
          message: `静音状态返回值无效:${String(silent)}`,
        });
        return;
      }
      setResult({
        status: 'success',
        message: `设备静音状态:${silent ? '是(true)' : '否(false)'}`,
      });
    } catch (error) {
      setResult({
        status: 'fail',
        message: `isAndroidDeviceSilent 调用失败:${errorMessage(error)}`,
      });
    }
  }, []);

  const queryMultiple = useCallback(async (count: number) => {
    setResult({
      status: 'running',
      message: `正在连续调用 isAndroidDeviceSilent ${count} 次...`,
    });
    try {
      const values: Array<boolean | null> = [];
      for (let index = 0; index < count; index += 1) {
        values.push(await isAndroidDeviceSilent());
      }
      const allValid = values.every((value) => typeof value === 'boolean');
      const stable = allValid && values.every((value) => value === values[0]);
      setResult({
        status: stable ? 'success' : 'fail',
        message: stable
          ? `连续 ${count} 次查询结果稳定:${values[0] ? '是' : '否'}`
          : `连续查询结果不一致或无效:${values.join(', ')}`,
        details: JSON.stringify(values),
      });
    } catch (error) {
      setResult({
        status: 'fail',
        message: `连续调用 isAndroidDeviceSilent 失败:${errorMessage(error)}`,
      });
    }
  }, []);

  return { result, query, queryMultiple };
}

export function useRingerListener() {
  const [listening, setListening] = useState(false);
  const [events, setEvents] = useState<string[]>([]);
  const [result, setResult] = useState<TestResult>(IDLE_RESULT);
  const subscriptionRef = useRef<Subscription | null>(null);

  const stop = useCallback(() => {
    const subscription = subscriptionRef.current;
    if (subscription) {
      removeRingerListener(subscription);
      subscriptionRef.current = null;
    }
    setListening(false);
    setResult({
      status: 'success',
      message: '铃声监听已停止;后续模式变化不应再新增事件',
    });
  }, []);

  const start = useCallback(() => {
    if (subscriptionRef.current) {
      setResult({
        status: 'success',
        message: '铃声监听已经开启,未重复注册',
      });
      return;
    }
    try {
      const subscription = addRingerListener((event: RingerSilentStatus) => {
        const valid =
          typeof event?.status === 'boolean' &&
          ['SILENT', 'VIBRATE', 'NORMAL', 'MUTED'].includes(event.mode);
        const text = `${formatTimestamp()} ${JSON.stringify(event)}`;
        setEvents((current) => [text, ...current].slice(0, 20));
        setResult(
          valid
            ? {
                status: 'success',
                message: '收到有效的 RNVMSilentEvent 事件',
                details: JSON.stringify(event),
              }
            : {
                status: 'fail',
                message: 'RNVMSilentEvent 事件负载无效',
                details: JSON.stringify(event),
              }
        );
      });
      subscriptionRef.current = subscription;
      setListening(true);
      setResult({
        status: 'running',
        message: '铃声监听已开启,请切换系统铃声模式验证事件',
      });
    } catch (error) {
      setResult({
        status: 'fail',
        message: `addRingerListener 调用失败:${errorMessage(error)}`,
      });
    }
  }, []);

  useEffect(() => {
    return () => {
      const subscription = subscriptionRef.current;
      if (subscription) {
        removeRingerListener(subscription);
        subscriptionRef.current = null;
      }
    };
  }, []);

  return { listening, events, result, start, stop };
}

export function useSilentCompatibilityListener() {
  const [listening, setListening] = useState(false);
  const [events, setEvents] = useState<string[]>([]);
  const [result, setResult] = useState<TestResult>(IDLE_RESULT);
  const subscriptionRef = useRef<Subscription | null>(null);

  const stop = useCallback(() => {
    subscriptionRef.current?.remove();
    subscriptionRef.current = null;
    setListening(false);
    setResult({
      status: 'success',
      message: '静音兼容监听已停止',
    });
  }, []);

  const start = useCallback(() => {
    if (subscriptionRef.current) {
      setResult({
        status: 'success',
        message: '静音兼容监听已经开启,未重复注册',
      });
      return;
    }
    try {
      const subscription = addSilentListener((event) => {
        const valid =
          typeof event?.isMuted === 'boolean' &&
          typeof event?.initialQuery === 'boolean';
        const text = `${formatTimestamp()} ${JSON.stringify(event)}`;
        setEvents((current) => [text, ...current].slice(0, 20));
        setResult({
          status: valid ? 'success' : 'fail',
          message: valid
            ? '收到真实的铃声/媒体静音兼容事件(非物理静音开关)'
            : '静音兼容事件负载无效',
          details: JSON.stringify(event),
        });
      });
      subscriptionRef.current = subscription;
      setListening(true);
      setResult({
        status: 'running',
        message: '正在查询初始状态并监听铃声模式变化...',
      });
    } catch (error) {
      setResult({
        status: 'fail',
        message: `addSilentListener 调用失败:${errorMessage(error)}`,
      });
    }
  }, []);

  useEffect(() => {
    return () => {
      subscriptionRef.current?.remove();
      subscriptionRef.current = null;
    };
  }, []);

  return { listening, events, result, start, stop };
}

export function useSilentSwitchCompatibility() {
  const status = useSilentSwitch();
  const result: TestResult = status
    ? {
        status: 'success',
        message: `兼容静音状态:${status.isMuted ? '静音' : '非静音'}`,
        details: JSON.stringify(status),
      }
    : {
        status: 'running',
        message: '正在等待 useSilentSwitch 初始兼容状态...',
      };
  return { status, result };
}

export function useAudioSessionOps() {
  const [result, setResult] = useState<TestResult>(IDLE_RESULT);
  const [events, setEvents] = useState<string[]>([]);

  const run = useCallback(async (label: string, action: () => Promise<void>) => {
    setResult({ status: 'running', message: `正在执行 ${label}...` });
    try {
      await action();
      const message = `${label} 原生调用成功完成`;
      setEvents((current) => [
        `${formatTimestamp()} ${message}`,
        ...current,
      ].slice(0, 20));
      setResult({ status: 'success', message });
    } catch (error) {
      setResult({
        status: 'fail',
        message: `${label} 调用失败:${errorMessage(error)}`,
      });
    }
  }, []);

  return {
    result,
    events,
    enableSession: () => run('enable(true)', () => enable(true)),
    activateSession: () => run('setActive(true)', () => setActive(true)),
    deactivateSession: () => run('setActive(false)', () => setActive(false)),
    setMixCategory: () =>
      run('setCategory(Ambient, true)', () => setCategory('Ambient', true)),
    setVoiceScene: () => run('setMode(VoiceChat)', () => setMode('VoiceChat')),
    setGameScene: () => run('setMode(GameChat)', () => setMode('GameChat')),
    setMediaScene: () => run('setMode(Default)', () => setMode('Default')),
  };
}

export function useVolumePanelOps() {
  const [result, setResult] = useState<TestResult>(IDLE_RESULT);
  const [events, setEvents] = useState<string[]>([]);
  const [panelEnabled, setPanelEnabled] = useState(false);

  const append = useCallback((message: string) => {
    setEvents((current) => [
      `${formatTimestamp()} ${message}`,
      ...current,
    ].slice(0, 20));
  }, []);

  const setAndVerify = useCallback(
    async (target: number, showUI: boolean) => {
      setResult({
        status: 'running',
        message: `正在通过 AVVolumePanel 设置媒体音量 ${target}(showUI=${showUI})...`,
      });
      try {
        await setVolume(target, { type: 'music', showUI });
        await new Promise<void>((resolve) => setTimeout(resolve, 2000));
        const current = await getVolume();
        const difference = Math.abs(current.volume - target);
        const message =
          `showUI=${showUI},目标=${target.toFixed(2)},实际=${current.volume.toFixed(4)},` +
          `误差=${difference.toFixed(4)}`;
        append(message);
        setResult({
          status: difference <= 0.15 ? 'success' : 'fail',
          message:
            difference <= 0.15
              ? showUI
                ? `showUI=true 调节成功,面板应出现在系统默认位置:${message}`
                : `showUI=false 调节成功,面板应保持隐藏:${message}`
              : `音量未达到允许误差范围:${message}`,
          details: JSON.stringify(current),
        });
      } catch (error) {
        setResult({
          status: 'fail',
          message: `AVVolumePanel 调节失败:${errorMessage(error)}`,
        });
      }
    },
    [append]
  );

  const setPanelVisible = useCallback(
    async (visible: boolean) => {
      setResult({
        status: 'running',
        message: `正在${visible ? '允许显示' : '关闭'}宿主音量面板...`,
      });
      try {
        await showNativeVolumeUI({ enabled: visible });
        setPanelEnabled(visible);
        const message = visible
          ? '已允许显示系统音量条,点击本身不会立刻弹出。请再切换系统音量查看面板'
          : '已关闭宿主音量面板。请再切换系统音量对比:宿主条不应出现';
        append(message);
        setResult({ status: 'success', message });
      } catch (error) {
        setResult({
          status: 'fail',
          message: `showNativeVolumeUI 调用失败:${errorMessage(error)}`,
        });
      }
    },
    [append]
  );

  return {
    result,
    events,
    panelEnabled,
    setQuarterVolumeHidden: () => setAndVerify(0.25, false),
    setThreeQuarterVolumeHidden: () => setAndVerify(0.75, false),
    setQuarterVolumeShown: () => setAndVerify(0.25, true),
    setThreeQuarterVolumeShown: () => setAndVerify(0.75, true),
    changeQuarterVolume: () => setAndVerify(0.25, panelEnabled),
    changeThreeQuarterVolume: () => setAndVerify(0.75, panelEnabled),
    showPanel: () => setPanelVisible(true),
    hidePanel: () => setPanelVisible(false),
  };
}