import media from '@ohos.multimedia.media';
import prompt from '@ohos.promptAction';
import { PlayerConstants, AVPlayerStatus, Events } from '../constants/PlayerConstants';
import { BusinessError } from '@ohos.base';
import { TrackingPlay } from 'wdTracking/Index';
import { ParamType } from 'wdTracking/Index';
import { DateTimeUtils, Logger, WindowModel } from 'wdKit/Index';
import { BackgroundAudioController } from './BackgroundAudioController';
import { audio } from '@kit.AudioKit';

interface obj {
  loop: boolean
}

const TAG = "WDPlayerController"

@Observed
export class WDPlayerController {
  private initPromise: Promise<void>;
  private avPlayer?: media.AVPlayer | null;
  private duration: number = 0;
  private status: number = PlayerConstants.STATUS_IDLE;
  private loop: boolean = true;
  private url: string = '';
  private surfaceId: string = ''; // 若播放音频，无需设置surfaceId
  private playSpeed: number = 1;
  private seekTime: number = 0;
  private positionY: number = 0;
  private startTime: number = 0;
  private pageParam: ParamType = {}
  private pageName: string = ''
  private creatStartTime:number = 0;//开始加载时间
  private creatEndTime:number = 0;//加载完成时间
  private prepareTime:number = 0; //加载时间
  private currentPlayTime:number = 0; //当前播放时间
  public onVideoSizeChange?: (width: number, height: number) => void;
  public onLoaded?: (loaded: number) => void;
  public onTimeUpdate?: (position: number, duration: number) => void;
  public onVolumeUpdate?: (volume: number) => void;
  public onBrightUpdate?: (volume: number) => void;
  public continue?: () => void;
  public onCanplay?: () => void;
  public onStatusChange?: (status: number) => void;
  public onSeekDone?: (time: number) => void;
  public xComponentController?: XComponentController
  public videoWidth: number = 0
  public videoHeight: number = 0
  public keepOnBackground = false
  private windowHeight: number = px2vp(AppStorage.get<number>('windowHeight') || 0)


  constructor(obj?: obj) {
    Logger.error("初始化")
    this.initPromise = this.createAVPlayer();
    if(obj?.loop === false) {
      this.loop = false
    }
  }

  /**
   * 创建 videoPlayer对象
   */
  private createAVPlayer(): Promise<void> {

    // const  windowClass = WindowModel.shared.getWindowClass();
    // this.bright = windowClass.getWindowProperties().brightness;
    // Logger.debug(TAG, ">>>>>>默认屏幕亮度："+this.bright)

    return new Promise((resolve, reject) => {
      Logger.debug(TAG, "开始创建")
      media.createAVPlayer().then((avPlayer) => {
        if (avPlayer) {
          Logger.debug(TAG, "创建完成1")
          this.avPlayer = avPlayer;
          this.bindState();
          resolve();
        } else {
          Logger.error(TAG, "创建完成0")
          Logger.error(TAG, '[PlayVideoModel] createAvPlayer fail!');
          reject();
        }
      }).catch((error: BusinessError) => {
        Logger.error(TAG, `AVPlayer catchCallback, error message:${error.message}`);
      });
      ;
    });
  }

  /**
   * AVPlayer 绑定事件.
   */
  private bindState() {
    this.avPlayer?.on(Events.STATE_CHANGE, async (state) => {
      //console.info(TAG,`cj2024 state = ${state}`)
      if (this.avPlayer == null) {
        return
      }
      switch (state) {
        case AVPlayerStatus.IDLE:
          this.resetProgress();
          this.avPlayer.url = this.url;
          break;
        case AVPlayerStatus.INITIALIZED:
          if (this.surfaceId) {
            this.avPlayer.surfaceId = this.surfaceId;
          }
          if(this.onLoaded) {
            this.onLoaded(1)
          }
         // 【华为验收】使用音频场景streamusage错误：STREAM_USAGE_MUSIC（音乐），应改为STREAM_USAGE_MOVIE（电影或视频），可以降低功耗
          this.avPlayer.audioRendererInfo = {
            usage: audio.StreamUsage.STREAM_USAGE_MOVIE,
            rendererFlags: 0
          }

          this.avPlayer?.prepare();
          break;
        case AVPlayerStatus.PREPARED:
          this.avPlayer.videoScaleType = 0;
          if (this.startTime) {
            this.setSeekTime(this.startTime, SliderChangeMode.Begin);
          }
        // this.avPlayer.play();
          this.duration = this.avPlayer.duration;
          if (this.onCanplay) {
            this.onCanplay()
          }
          this.avPlayer.loop = this.loop
          break;
        case AVPlayerStatus.PLAYING:
          if(this.onLoaded) {
            this.onLoaded(2)
          }
          // this.setBright();
          this.status = PlayerConstants.STATUS_START;
          this.avPlayer!.videoScaleType = media.VideoScaleType.VIDEO_SCALE_TYPE_FIT
          this.watchStatus();
          break;
        case AVPlayerStatus.PAUSED:
          this.status = PlayerConstants.STATUS_PAUSE;
          this.watchStatus();
          break;
        case AVPlayerStatus.COMPLETED:
        // this.titleThis.playSpeed = 1;
          if (this.continue) {
            this.continue();
          } else {
            if(this.loop) {
              this.duration = 0;
              this.url = this.avPlayer.url || '';
              this.avPlayer.reset();
            }
            this.status = PlayerConstants.STATUS_COMPLETION;
            this.watchStatus();
          }
          break;
        case AVPlayerStatus.RELEASED:
          this.avPlayer.release();
          this.status = PlayerConstants.STATUS_STOP;
          this.watchStatus();
          Logger.info(TAG, '[PlayVideoModel] state released called')
          break;
        default:
          Logger.info(TAG, '[PlayVideoModel] unKnown state: ' + state);
          break;
      }
    });
    this.avPlayer?.on(Events.TIME_UPDATE, (time: number) => {
      this.initProgress(time);
    });
    this.avPlayer?.on(Events.ERROR, (error) => {
      // this.playError(error.message);
      Logger.error(TAG, '播放错误' + JSON.stringify(error))
      TrackingPlay.videoPlayError(error.message, this.pageName, this.pageName, this.pageParam)
    })
    this.avPlayer?.on('seekDone', (time: number) => {
      this.initProgress(time);
      if (this.onSeekDone) {
        this.onSeekDone(time);
      }
    })
    this.avPlayer?.on(Events.VIDEO_SIZE_CHANGE, (width: number, height: number) => {
      if (this.onVideoSizeChange) {
        this.onVideoSizeChange(width, height);
      }
      this.videoWidth = width
      this.videoHeight = height
    })
    this.avPlayer?.on(Events.AUDIOINTERRUPT, async(interruptEvent: audio.InterruptEvent) => {
      //https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/media/audio/audio-playback-concurrency.md#%E5%A4%84%E7%90%86%E9%9F%B3%E9%A2%91%E7%84%A6%E7%82%B9%E4%BA%8B%E4%BB%B6
      if (interruptEvent.forceType === audio.InterruptForceType.INTERRUPT_FORCE) {
        switch (interruptEvent.hintType) {
          case audio.InterruptHint.INTERRUPT_HINT_RESUME:
            await this.play()
            break;
          case audio.InterruptHint.INTERRUPT_HINT_PAUSE:
            // 此分支表示系统已将音频流暂停（临时失去焦点），为保持状态一致，应用需切换至音频暂停状态
            // 临时失去焦点：待其他音频流释放音频焦点后，本音频流会收到resume对应的音频打断事件，到时可自行继续播放
          case audio.InterruptHint.INTERRUPT_HINT_STOP:
            // 此分支表示系统已将音频流停止（永久失去焦点），为保持状态一致，应用需切换至音频暂停状态
            // 永久失去焦点：后续不会再收到任何音频打断事件，若想恢复播放，需要用户主动触发。
            // this.avPlayer?.play()
            await this.pause()
            break;
        }
      }else if (interruptEvent.forceType === audio.InterruptForceType.INTERRUPT_SHARE) {
        // 共享打断类型（INTERRUPT_SHARE）：应用可自主选择执行相关操作或忽略音频打断事件
        switch (interruptEvent.hintType) {
          case audio.InterruptHint.INTERRUPT_HINT_PAUSE:
          case audio.InterruptHint.INTERRUPT_HINT_RESUME:
            // 此分支表示临时失去焦点后被暂停的音频流此时可以继续播放，建议应用继续播放，切换至音频播放状态
            // 若应用此时不想继续播放，可以忽略此音频打断事件，不进行处理即可
            // 继续播放，此处主动执行start()，以标识符变量started记录start()的执行结果
            // await audioRenderer.start().then(() => {
            //   started = true; // start()执行成功
            // }).catch((err: BusinessError) => {
            //   started = false; // start()执行失败
            // });
            // // 若start()执行成功，则切换至音频播放状态
            // if (started) {
            //   isPlay = true; // 此句为简化处理，代表应用切换至音频播放状态的若干操作
            // } else {
            //   // 音频继续播放执行失败
            // }
            this.avPlayer?.play()
            break;
          default:
            break;
        }
      }
    })
  }

  public setXComponentController(controller: XComponentController) {
    this.surfaceId = controller.getXComponentSurfaceId()
    this.xComponentController = controller
  }

  setSurfaceId(surfaceId: string) {
    this.surfaceId = surfaceId
  }

  async firstPlay(url: string,pageId?: string, pageName?: string, pageParam?: ParamType) {
    this.url = url;
    //加载时长prepareTime
    this.creatStartTime = DateTimeUtils.getTimeStamp()
    Logger.debug(TAG, '开始创建' + JSON.stringify(this.creatStartTime))
    this.prepareTime = 0
    if(pageName){
      this.pageName = pageName
    }
    if(pageParam){
      this.pageParam = pageParam
    }
    if (this.avPlayer == null) {
      Logger.debug(TAG, "等待")
      this.initPromise = this.createAVPlayer();
      await this.initPromise;
    } else {
      if (this.avPlayer.state != AVPlayerStatus.IDLE) {
        await this.avPlayer.stop()
        await this.avPlayer.release()
        this.initPromise = this.createAVPlayer();
        await this.initPromise;
      }
    }
    if (this.avPlayer == null) {
      return
    }
    Logger.debug(TAG, "开始播放", this.url)
    this.avPlayer.url = this.url;
    //加载时长prepareTime
    this.creatEndTime = DateTimeUtils.getTimeStamp()
    this.prepareTime = 0
    this.prepareTime = Math.floor((this.creatEndTime - this.creatStartTime)/1000)
    Logger.debug(TAG, '开始播放2',JSON.stringify(this.prepareTime))
  }

  async release() {
    // if (this.avPlayer == null) {
    //   await this.initPromise;
    // }
    if (this.avPlayer == null) {
      return
    }
    this.avPlayer.release()
    this.avPlayer = null

  }

  async pause() {
    // if (this.avPlayer == null) {
    //   await this.initPromise;
    // }
    // if (this.avPlayer == null) {
    //   return
    // }
    Logger.debug(TAG, "start pause")
    this.avPlayer?.pause();
  }

  async resume() {
    if (this.status == PlayerConstants.STATUS_PAUSE) {
      Logger.debug(TAG, "start resume")
      this.avPlayer?.play();
      return
    }
    if (this.status == PlayerConstants.STATUS_COMPLETION) {
      Logger.debug(TAG, "start resume")
      this.avPlayer?.seek(0);
      this.avPlayer?.play();
      return
    }
    this.play()
  }

  async play() {
    // if (this.avPlayer == null) {
    //   await this.initPromise;
    // }
    // if (this.avPlayer == null) {
    //   return
    // }
    //Logger.debug(TAG, "start play")
    this.avPlayer?.prepare().then(() => {
      this.avPlayer?.play()
    }, (err: BusinessError) => {
      console.error(TAG,'Failed to prepare,error message is :' + err.message)
      //this.avPlayer?.stop()
    })
  }

  async startRenderFrame(cb: Function) {
    this.avPlayer?.on('startRenderFrame', () => {
      cb && cb();
      Logger.debug(TAG, 'startRenderFrame success')
    })
  }

  async stop() {
    // if (this.avPlayer == null) {
    //   await this.initPromise;
    // }
    // if (this.avPlayer == null) {
    //   return
    // }
    this.avPlayer?.stop();
  }

  async setLoop() {
    // if (this.avPlayer == null) {
    //   await this.initPromise;
    // }
    // if (this.avPlayer == null) {
    //   return
    // }
    this.loop = !this.loop;
  }

  async setSpeed(playSpeed: number) {
    // if (this.avPlayer == null) {
    //   await this.initPromise;
    // }
    // if (this.avPlayer == null) {
    //   return
    // }
    if (this.avPlayer && PlayerConstants.OPERATE_STATE.indexOf(this.avPlayer?.state) === -1) {
      return;
    }
    this.playSpeed = playSpeed;
    this.avPlayer?.setSpeed(this.playSpeed);
  }

  async switchPlayOrPause() {
    // if (this.avPlayer == null) {
    //   await this.initPromise;
    // }
    // if (this.avPlayer == null) {
    //   return
    // }
    if (this.status === PlayerConstants.STATUS_START) {
      Logger.debug(TAG, "start pause 1111")
      this.avPlayer?.pause();
    } else {
      this.avPlayer?.play();
    }
  }

  async setSeekTime(value: number, mode: SliderChangeMode) {
    // if (this.avPlayer == null) {
    //   await this.initPromise;
    // }
    // if (this.avPlayer == null) {
    //   return
    // }
    // if (mode == SliderChangeMode.Begin) {
    //   this.seekTime = value * 1000;
    //   this.avPlayer?.seek(this.seekTime, media.SeekMode.SEEK_PREV_SYNC);
    // }
    // 防止seek报错
    if (this.avPlayer && PlayerConstants.OPERATE_STATE.indexOf(this.avPlayer?.state) === -1) {
      return;
    }

    if (mode === SliderChangeMode.Moving) {
      // this.progressThis.progressVal = value;
      // this.progressThis.currentTime = DateFormatUtil.secondToTime(Math.floor(value * this.duration /
      // 100 / 1000));
    }
    if (mode === SliderChangeMode.End) {
      // Logger.warn(`cj2024 seekTime = ${value}`)
      // Logger.warn(`cj2024 duration = ${this.duration}`)
      this.seekTime = Math.floor(value * this.duration / 100);
      // Logger.warn(`cj2024 seekTime = ${this.seekTime}`)
      this.currentPlayTime = this.seekTime
      this.avPlayer?.seek(this.seekTime,media.SeekMode.SEEK_CLOSEST);
    }
  }
  async setSeekMicroSecondsTime(value: number) {
    // 防止seek报错
    if (this.avPlayer && PlayerConstants.OPERATE_STATE.indexOf(this.avPlayer?.state) === -1) {
      return;
    }
    this.avPlayer?.seek(value);

    if (this.status == PlayerConstants.STATUS_PAUSE) {
      this.avPlayer?.play()
    }
  }

  getStatus() {
    return this.status;
  }

  getUrl() {
    return this.url
  }

  getPlayer() {
    return this.avPlayer;
  }

  initProgress(time: number) {
    this.currentPlayTime=Math.floor(time / 1000);
    let nowSeconds = Math.floor(time / 1000);
    let totalSeconds = Math.floor(this.duration / 1000);

    if (this.keepOnBackground) {
      BackgroundAudioController.sharedController().setSessionPlayProgress(time, this.duration)
    }

    if (this.onTimeUpdate) {
      this.onTimeUpdate(time, this.duration);
    }
  }

  resetProgress() {
    this.seekTime = 0;
    // this.progressThis.currentTime = '00:00';
    // this.progressThis.progressVal = 0;
  }

  resetPlay() {
    this.duration = 0;
    this.url = this.avPlayer?.url || '';
    this.avPlayer?.reset();
  }

  onVolumeActionStart(event: GestureEvent) {
    if (!event) {
      return;
    }
    this.positionY = event.offsetY;
  }

  volume: number = 1
  bright: number = 1

  onVolumeActionUpdate(event: GestureEvent) {
    if (!this.avPlayer) {
      return
    }
    if (PlayerConstants.OPERATE_STATE.indexOf(this.avPlayer.state) === -1) {
      return;
    }
    let changeVolume = (event.offsetY - this.positionY) / this.windowHeight;
    let currentVolume = this.volume - changeVolume;
    if (currentVolume > 1) {
      currentVolume = 1;
    }
    if (currentVolume <= 0) {
      currentVolume = 0;
    }
    this.volume = currentVolume;
    // Logger.debug(TAG, "changeVolume : " + changeVolume)
    // Logger.debug(TAG, "windowHeight : " + this.windowHeight)
    // Logger.debug(TAG, "volume : " + this.volume)
    this.avPlayer?.setVolume(this.volume);
    this.positionY = event.offsetY;
    if (this.onVolumeUpdate) {
      this.onVolumeUpdate(this.volume);
    }
  }

  onBrightActionStart(event: GestureEvent) {
    if (!event) {
      return;
    }
    this.positionY = event.offsetY;
  }

  setBright() {
    const windowClass = WindowModel.shared.getWindowClass();
    windowClass.setWindowBrightness(this.bright)
  }

  onBrightActionUpdate(event: GestureEvent) {

    let changeBright = (event.offsetY - this.positionY) / this.windowHeight;
    let currentBright = this.bright - changeBright;
    if (currentBright > 1) {
      currentBright = 1;
    }
    if (currentBright <= 0.1) {
      currentBright = 0.1;
    }
    this.bright = currentBright;
    // Logger.debug(TAG, "changeBright : " + changeBright)
    // Logger.debug(TAG, "windowHeight : " + this.windowHeight)
    // Logger.debug(TAG, "bright : " + this.bright)
    this.setBright()
    this.positionY = event.offsetY;
    if (this.onBrightUpdate) {
      this.onBrightUpdate(this.bright);
    }
  }

  onActionEnd() {
    setTimeout(() => {
      this.positionY = 0;
    }, 200);
  }

  watchStatus() {

    if (this.keepOnBackground) {
      BackgroundAudioController.sharedController().setSessionPlayStatus(this.status)
    }

    Logger.debug(TAG, 'watchStatus ' + this.status)
    if(this.status == PlayerConstants.STATUS_START){
      // Logger.debug(TAG, '播放视频')
      // Logger.debug(TAG, '播放视频prepareTime' + JSON.stringify(this.prepareTime))
      // Logger.debug(TAG, '播放视频pageName' + JSON.stringify(this.pageName))
      // Logger.debug(TAG, '播放视频pageParam' + JSON.stringify(this.pageParam))
      // 播放埋点
      TrackingPlay.videoPositivePlay(Number(this.prepareTime),this.pageName, this.pageName, this.pageParam)
    }
    if(this.status == PlayerConstants.STATUS_COMPLETION){
      let initDuration = Math.floor(Number(this.duration)/1000)
      // Logger.debug(TAG, '播放结束')
      // Logger.debug(TAG, '播放结束currentPlayTime' + JSON.stringify(this.currentPlayTime))
      // Logger.debug(TAG, '播放结束initDuration' + JSON.stringify(initDuration))
      // Logger.debug(TAG, '播放结束pageName' + JSON.stringify(this.pageName))
      // Logger.debug(TAG, '播放结束pageParam' + JSON.stringify(this.pageParam))
      // 播放结束埋点
      TrackingPlay.videoPlayEnd(this.currentPlayTime, initDuration, this.currentPlayTime, this.pageName, this.pageName, this.pageParam)
    }
    if (this.onStatusChange) {
      this.onStatusChange(this.status)
    }
    // if (this.status === PlayConstants.STATUS_START) {
    //   globalThis.windowClass.setWindowKeepScreenOn(true);
    // } else {
    //   globalThis.windowClass.setWindowKeepScreenOn(false);
    // }
  }

  playError(msg?: string) {
    prompt.showToast({
      duration: 3000,
      message: msg ? msg : "请检查地址输入正确且网络正常"
    });
  }

  setStartTime(time?: number) {
    this.startTime = time ?? 0;
  }
}