import {
  GET_ROOM_LIST,
  GET_ROOM_MINI_CODE,
  DEL_ROOM,
  SET_ROOM,
  GET_ROOM,
  GET_ROOM_LEADER_MINI_CODE,
  ROOM_ACTION_CHECKER
} from './constant'
import axios from './instance'
import type { PageResult, Scene } from './'
import type { SScene } from './scene'
import type { Dayjs } from 'dayjs'
import { head } from 'lodash-es'

export type SRoom = {
  roomId: number
  roomTitle: string
  roomInfo: string
  roomHostName: string
  roomStatus: number
  hostStatus: number
  roomCoverUrl: string
  roomViewCount: number
  createTime: string
  useTimeList?: [Dayjs, Dayjs],
  visitPassword?: string,
  maxMan?: number,
  isRoamMode?: boolean,
  freeRoamLock?: number
  takeLookLock?: number
  userObjList?: AuthUser[]
  location?: string
  image?: string[]
  head?: string
  gps?: string
  video?: string[]
}

export interface RoomScene {
  num: string
  title: string
  cover: string
}

export type AuthUser = {
  userName: string
  useTimeList?: [Dayjs, Dayjs]
}
export interface Room {
  id: number
  title: string
  desc: string
  time: string
  viewCount: number
  cover: string
  leaderName: string
  roomStatus?: number
  hostStatus?: number
  useTimeList?: [Dayjs, Dayjs],
  visitPassword?: string,
  maxMan?: number,
  isRoamMode?: boolean,
  freeRoamLock?: number
  takeLookLock?: number
  userObjList?: AuthUser[],
  scenesAvatar?: string
  scenesAlbum?: string[]
  scenesVideo?: string
  gps?: string

}

export type Rooms = Room[]

const serverToLocal = (sroom: SRoom): Room => ({
  id: sroom.roomId,
  title: sroom.roomTitle,
  desc: sroom.roomInfo,
  time: sroom.createTime,
  viewCount: sroom.roomViewCount,
  cover: sroom.roomCoverUrl,
  leaderName: sroom.roomHostName,
  useTimeList: sroom.useTimeList,
  maxMan: sroom.maxMan,
  roomStatus: sroom.roomStatus,
  hostStatus: sroom.hostStatus,
  visitPassword: sroom.visitPassword,
  userObjList: sroom.userObjList,
  scenesAlbum: sroom.image,
  scenesAvatar: sroom.head,
  scenesVideo: sroom.video?.length ? sroom.video[0] : '',
})
const localToServer = (room: Room): SRoom => ({
  roomId: room.id,
  roomTitle: room.title,
  roomInfo: room.desc,
  roomHostName: room.leaderName,
  roomCoverUrl: room.cover,
  roomViewCount: room.viewCount,
  createTime: room.time,
  roomStatus: room.roomStatus || 0,
  hostStatus: room.roomStatus || 0,
  useTimeList: room.useTimeList,
  maxMan: room.maxMan,
  visitPassword: room.visitPassword,
  takeLookLock: room.takeLookLock || 0,
  freeRoamLock: room.freeRoamLock || 0,
  userObjList: room.userObjList,
  image: room.scenesAlbum,
  head: room.scenesAvatar,
  video: [room.scenesVideo || ''],
})

export const fetchRomms = async (status: number = 1): Promise<Rooms> => {
  const res = await axios.post<PageResult<SRoom>>(GET_ROOM_LIST, {
    pageNum: 1,
    pageSize: 1000,
    roomStatus: status,
  })
  const rooms = res.list.map(serverToLocal)
  return rooms
}

export const deleteRoom = async (room: Room) => {
  await axios.post(DEL_ROOM, { roomId: room.id })
}

export const insertRoom = async (
  room: Omit<Room, 'id'>,
  numList: Scene['num'][],

) => {
  const param = {
    ...localToServer({ ...room, id: -1 }),
    roomId: null,
    createTime: null,
    numList
  }
  console.log('param', param)
  const sroom = await axios.post<SRoom>(SET_ROOM, param)
  return serverToLocal(sroom)
}

export const updateRoom = async (room: Room, numList: Scene['num'][]) => {
  await axios.post(SET_ROOM, {
    ...localToServer(room),
    numList
  })
}

export const fetchRoomMiniCode = async (room: Room) => {
  return axios.get<string>(GET_ROOM_MINI_CODE, { params: { roomId: room.id } })
}

export const fetchLeaderRoomMiniCode = async (room: Room) => {
  return axios.get<string>(GET_ROOM_LEADER_MINI_CODE, {
    params: { roomId: room.id }
  })
}
interface RoomDetailType extends SRoom {
  sceneData: SScene[],
}
export const fetchRoomDetail = async (roomId: Room['id']) => {
  const res = await axios.get<RoomDetailType>(GET_ROOM, {
    params: { roomId }
  })
  return res
}
export const checkRoomEditOrDel = async (room: Room) => {
  return axios.get<string>(ROOM_ACTION_CHECKER, {
    params: { roomId: room.id }
  })
}