/* eslint no-param-reassign: "off" */
import { types, flow } from 'mobx-state-tree';
import Moment from 'moment';
import 'moment/locale/ru';
import Api from '../Service/Api';
import ClinicStore from './ClinicStore';
import DoctorStore from './DoctorStore';
import ServiceStore from './ServiceStore';
import ChatStore from './ChatStore';
import ScheduleStore from './ScheduleStore';
import BookingStore from './BookingStore';
import UserStore from './UserStore';

const MainStore = types.model('MainStore', {
  doctor: types.maybe(types.reference(DoctorStore)),
  clinic: types.maybe(types.reference(ClinicStore)),
  service: types.maybe(types.reference(ServiceStore)),
  chat: types.maybe(types.reference(ChatStore)),
  schedule: types.maybe(types.reference(ScheduleStore)),
  appointment: types.maybe(types.reference(BookingStore)),
  booking: BookingStore,
  user: UserStore,

  doctorList: types.array(DoctorStore),
  clinicList: types.array(ClinicStore),
  serviceList: types.array(ServiceStore),
  popularServiceList: types.optional(types.array(types.reference(ServiceStore)), []),
  chatList: types.array(ChatStore),
  scheduleList: types.array(ScheduleStore),
  appointmentList: types.array(BookingStore),

  doctorListFiltrated: types.array(types.reference(DoctorStore)),
  clinicListFiltrated: types.array(types.reference(ClinicStore)),
  serviceListFiltrated: types.array(types.reference(ServiceStore)),

  fetching: false,
}).actions((self => ({
  afterCreate: () => {
  },
  loadData: flow(function* loadData() {
    self.setFetching(true);
    try {
      const serviceResponse = yield Api.getServiceList();
      if (
        serviceResponse &&
        serviceResponse.status &&
        serviceResponse.data.services &&
        Number(serviceResponse.data.code) === 200
      ) {
        self.setServiceList(serviceResponse.data.services);
        self.setServiceListFiltrated(self.serviceList);
      }
      const doctorResponse = yield Api.getDoctorList();
      if (
        doctorResponse &&
        doctorResponse.status &&
        doctorResponse.data.doctors &&
        Number(doctorResponse.data.code) === 200
      ) {
        self.setDoctorList(doctorResponse.data.doctors.map((doctor) => {
          const servicesIdList = serviceResponse.data.services
            .filter(service => service.doctors.some(d => d.id === doctor.id))
            .map(s => String(s.id));

          return {
            ...doctor,
            serviceList: servicesIdList,
          };
        }));
        self.setDoctorListFiltrated(self.doctorList);
      }
      const clinicResponse = yield Api.getClinicList();
      if (
        clinicResponse &&
        clinicResponse.ok &&
        clinicResponse.data &&
        Number(clinicResponse.data.code) === 200
      ) {
        self.setClinicList(clinicResponse.data.clinics.map((clinic) => {
          const servicesIdList = serviceResponse.data.services
            .filter(service => service.clinics.some(c => c.id === clinic.id))
            .map(s => String(s.id));
          const doctorsIdList = doctorResponse.data.doctors
            .filter(doctor => doctor.clinics.some(c => c.id === clinic.id))
            .map(d => String(d.id));

          return {
            ...clinic,
            serviceList: servicesIdList,
            doctorList: doctorsIdList,
          };
        }));
        self.setClinicListFiltrated(self.clinicList);
      }
      const appointmentResponse = yield Api.getAppointmentList(self.user.id);
      if (
        appointmentResponse &&
        appointmentResponse.ok &&
        appointmentResponse.data &&
        appointmentResponse.data.data &&
        appointmentResponse.data.data.listPacients &&
        Number(appointmentResponse.data.code) === 200
      ) {
        const protocolList = [];
        const pacientList = Array.isArray(appointmentResponse.data.data.listPacients)
          ? appointmentResponse.data.data.listPacients
          : [appointmentResponse.data.data.listPacients];
        pacientList.forEach((patient, patientIndex) => {
          patient.listProtocol.forEach((protocol, protocolIndex) => {
            const possibleDoctors = self.doctorList.filter(doc => doc.name === protocol.specialist);
            let doctor = null;
            if (possibleDoctors.length) {
              doctor = possibleDoctors[0].id;
            }
            const serviceList = self.serviceList.filter(ser => ser.title === protocol.header);
            protocolList.push({
              id: `${patientIndex}-${protocolIndex}`,
              user: self.user.id,
              date: new Date(protocol.dateReceipt),
              doctor,
              serviceList,
              status: BookingStore.STATUS.RECORDED,
            });
          });
        });
        self.setAppointmentList(protocolList);
      }
      self.setPopularServiceList(['002978', '000032']);
    } catch (ex) {
      console.error(ex, 'ERROR! the data upload failed');
    } finally {
      self.setFetching(false);
    }
  }),
  getScheduleList: flow(function* getScheduleList(clinicId, doctorId, offset = 0) {
    const result = [];
    try {
      const response = yield Api.getScheduleList(clinicId, doctorId, offset);
      if (
        response &&
        response.status &&
        Number(response.data.code) === 200 &&
        response.data.grid &&
        response.data.dates
      ) {
        response.data.dates.forEach((date, index) => {
          const schedule = {
            date: new Date(date),
            id: `${date}_${index}`,
            timeList: [],
          };
          if (response.data.grid.length > index &&
            response.data.grid[index].some(g => String(g.status) !== ScheduleStore.NOT_AVAILABLE)) {
            schedule.timeList = response.data.grid[index]
              .filter(g => Number(g.status) !== ScheduleStore.NOT_AVAILABLE)
              .map(g => ({
                ...g,
                status: String(g.status),
                id: `${schedule.id}_${g.time}`,
              }));
          }
          result.push(schedule);
        });
      }
    } catch (ex) {
      console.error(ex, 'ERROR! getScheduleList');
    }

    return result;
  }),
  enroll: () => {
    const {
      user, doctor, clinic, serviceList, date, time,
    } = self.booking;
    let result = new Promise((resolve, reject) => reject());
    if (
      doctor &&
      clinic &&
      date &&
      time &&
      user &&
      user.phone && user.birthday && user.firstName && user.lastName &&
      serviceList && serviceList.length
    ) {
      Moment.locale('ru');
      result = Api.enroll(
        clinic.id, doctor.id, serviceList[0].id, Moment(date).format('YYYY-MM-DD'), time,
        user.lastName, user.firstName, user.patronymic, Moment(user.birthday).format('YYYY-MM-DD'), user.phone,
      ).then(res => res).catch(ex => console.error(ex, 'ERROR! enroll'));
    }
    return result;
  },
  login: flow(function* login(phone, password) {
    return yield Api.login(phone, password);
  }),
  orderValidation: (orderId, smsCode) => Api.orderValidation(orderId, smsCode),
  setFetching: (value) => {
    self.fetching = value;
  },
  setDoctorList: (value) => {
    self.doctorList = value;
  },
  setAppointmentList: (value) => {
    self.appointmentList = value;
  },
  setServiceList: (value) => {
    self.serviceList = value;
  },
  setPopularServiceList: (value) => {
    self.popularServiceList = value;
  },
  setClinicList: (value) => {
    self.clinicList = value;
  },
  setScheduleList: (value) => {
    self.scheduleList = value;
  },
  setDoctorListFiltrated: (value) => {
    self.doctorListFiltrated = value ? value.map(d => String(d.id)) : [];
  },
  setServiceListFiltrated: (value) => {
    self.serviceListFiltrated = value ? value.map(s => String(s.id)) : [];
  },
  setClinicListFiltrated: (value) => {
    const ids = value ? value.map(c => String(c.id)) : [];
    self.clinicListFiltrated = ids;
  },
  setDoctor: (value) => {
    self.doctor = value;
  },
  setClinic: (value) => {
    self.clinic = value;
  },
  setService: (value) => {
    self.service = value;
  },
  setSchedule: (value) => {
    self.schedule = value;
  },
  setUser: (value) => {
    self.user = value;
    if (value) {
      self.booking.setUser(self.user.id);
    }
  },
  setBooking: (value) => {
    self.booking = value;
  },
  clearBooking: () => {
    self.booking.setClinic(null);
    self.booking.setDoctor(null);
    self.booking.setServiceList([]);
    self.booking.setDate(null);
    self.booking.setTime(null);
  },
  setAppointment: (value) => {
    self.appointment = value;
  },
})))
  .views((self => ({
    getClinicList({ serviceId, doctorId }) {
      let list = self.clinicList.slice(0);
      if (serviceId) {
        list = list.filter(clinic => clinic.serviceList.some(s => s.id === serviceId));
      }
      if (doctorId) {
        list = list.filter(clinic => clinic.doctorList.some(d => d.id === doctorId));
      }
      return list;
    },
  })));

export default MainStore.create({
  chatList: [],
  popularServiceList: [],
  serviceList: [],
  doctorList: [],
  clinicList: [],
  serviceListFiltrated: [],
  doctorListFiltrated: [],
  clinicListFiltrated: [],
  scheduleList: [],
  appointmentList: [],
  booking: {
    id: '-1',
    serviceList: [],
    status: BookingStore.STATUS.RECORDED,
  },
  user: {
    idPacient: '0',
    phone: '+7(905)052-12-43',
    password: 'p8rpc6',
  },
  clinic: '1',
  doctor: '00007',
});