import axios from 'axios';

import { createStore } from 'vuex';
import {
  APPOINTMENT_DETAILS_API,
  LABS_DELETE_API,
  LABS_LIST_API,
  LABS_UPDATE_API,
  MEETING_NOTES_API,
  MEETING_PRESCREPTIONS_API,
  PATIENT_DELETE_API,
  PATIENT_LIST_API,
  PATIENT_MEETING_LIST_API,
  PATIENT_UPDATE_API,
  PROVIDER_DELETE_API,
  PROVIDER_LIST_API,
  PROVIDER_UPDATE_API
} from './constants.js';



export default createStore({
  state: {
    isLoading: false,
    patientList:[],
    patientMeetingList:[],
    providersList:[],
    labsList:[],
    singlePatientAppointment: null,
    patientPrescription:null,
    patientNotes: null,
  },
  mutations: {
    setLoading(state, payload) {
      console.log('payload');
        state.isLoading = payload
    },
    setPtientList(state, payload) {
      state.patientList = payload
    },
    setPtientMeetingList(state, payload) {
      state.patientMeetingList = payload
    },
    setProvidersList(state, payload) {
      state.providersList = payload
    },
    setLabsList(state, payload) {
      state.labsList = payload
    },
    setPrescription(state, payload) {
      state.patientPrescription = payload
    },
    setSinglePatientAppointment(state, payload) {
      state.singlePatientAppointment = payload
    },
    setPatientNotes(state, payload) {
      state.patientNotes = payload
    },
    
  },
  actions: {
    
    async updateIsLoading({ commit }, payload) {
        commit('setLoading', payload)
    },
    async patientList({ commit }, payload) {
      commit('setLoading', true)
      console.log(localStorage.getItem('admin_access_token'))
      await axios.post(PATIENT_LIST_API, {}, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
      })  .then(response => {
              commit('setLoading', false)
            console.log('Response:', response.data.patients);
            let dataArray =[]
            for (let data of response.data.patients) {
              let dataObject = {}
              dataObject.name = data.first_name + ' ' + data.last_name
              dataObject.first_name = data.first_name 
              dataObject.last_name =  data.last_name
              dataObject.email = data.email
              dataObject.dob = data.dob
              dataObject.phone_no = data.phone_no
              dataObject.avatar = '',
              dataObject.id = data.id,
              dataArray.push(dataObject)
            }
            console.log(dataArray)
            commit('setPtientList',dataArray)
  
          })
          .catch(error => {
            commit('setLoading', false)
            console.error('Error:', error);
          });
    },
    async patientMeetingList({ commit }, payload) {
      commit('setLoading', true)
      console.log(localStorage.getItem('admin_access_token'))
      await axios.post(PATIENT_MEETING_LIST_API+payload.id, {}, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
      })  .then(response => {
              commit('setLoading', false)
            console.log('Meeting Response:', response.data.patients);
            commit('setPtientMeetingList',response.data.patients);

           })
           .catch(error => {
             commit('setLoading', false)
             console.error('Error:', error);
           });
    },
    async patientUpdate({ commit }, payload) {
      commit('setLoading', true)
      await axios.post(PATIENT_UPDATE_API+payload.id, {
        first_name: payload.first_name,
        last_name: payload.last_name,
        email: payload.email,
        phone_no: payload.phone_no,
        dob: payload.dob,
      }, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
      })  .then(response => {
            commit('setLoading', false)
            console.log('Response:', response.data);
  
          })
          .catch(error => {
            commit('setLoading', false)
            console.error('Error:', error);
          });
    },
    async patientDelete({ commit }, payload) {
      commit('setLoading', true)
      console.log(localStorage.getItem('admin_access_token'))
      await axios.post(PATIENT_DELETE_API+payload.id, {}, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
      })  .then(response => {
            commit('setLoading', false)
            console.log('Response:', response.data);
  
          })
          .catch(error => {
            commit('setLoading', false)
            console.error('Error:', error);
          });
    },
    async providersList({ commit }, payload) {
      commit('setLoading', true)
      console.log(localStorage.getItem('admin_access_token'))
      await axios.post(PROVIDER_LIST_API, {}, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
      })  .then(response => {
              commit('setLoading', false)
            console.log('Response:', response.data.patients);
            let dataArray =[]
            for (let data of response.data.patients) {
              let dataObject = {}
              dataObject.name = data.first_name + ' ' + data.last_name
              dataObject.first_name = data.first_name 
              dataObject.last_name =  data.last_name
              dataObject.email = data.email
              // dataObject.dob = data.dob
              dataObject.phone_no = data.phone_number
              dataObject.avatar = '',
              dataObject.id = data.id,
              dataArray.push(dataObject)
            }
            console.log(dataArray)
            commit('setProvidersList',dataArray)
  
          })
          .catch(error => {
            commit('setLoading', false)
            console.error('Error:', error);
          });
    },
    async providerUpdate({ commit }, payload) {
      commit('setLoading', true)
      await axios.post(PROVIDER_UPDATE_API+payload.id, {
        first_name: payload.first_name,
        last_name: payload.last_name,
        email: payload.email,
        phone_number: payload.phone_no,
      }, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
      })  .then(response => {
            commit('setLoading', false)
            console.log('Response:', response.data);
  
          })
          .catch(error => {
            commit('setLoading', false)
            console.error('Error:', error);
          });
    },
    async providerDelete({ commit }, payload) {
      commit('setLoading', true)
      console.log(localStorage.getItem('admin_access_token'))
      await axios.post(PROVIDER_DELETE_API+payload.id, {}, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
      })  .then(response => {
            commit('setLoading', false)
            console.log('Response:', response.data);
  
          })
          .catch(error => {
            commit('setLoading', false)
            console.error('Error:', error);
          });
    },
    async labsList({ commit }, payload) {
      commit('setLoading', true)
      console.log(localStorage.getItem('admin_access_token'))
      await axios.post(LABS_LIST_API, {}, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
      })  .then(response => {
              commit('setLoading', false)
            console.log('Response:', response.data);
            let dataArray =[]
            for (let data of response.data.patients) {
              let dataObject = {}
              dataObject.name = data.name
              dataObject.address = data.address 
              dataObject.slot_date =  data.slot_date
              dataObject.slot_time =  data.slot_time
              dataObject.appointment_id = data.appointment_id
              dataObject.booking_time = data.booking_time
              dataObject.contact_no = data.contact_no
              dataObject.avatar = '',
              dataObject.id = data.id,
              dataArray.push(dataObject)
            }
            console.log(dataArray)
            commit('setLabsList',dataArray)
  
          })
          .catch(error => {
            commit('setLoading', false)
            console.error('Error:', error);
          });
    },
    async labUpdate({ commit }, payload) {
      commit('setLoading', true)
      await axios.post(LABS_UPDATE_API+payload.id, {
        name: payload.name,
        address: payload.address,
        contact_no: payload.contact_no,
      }, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
      })  .then(response => {
            commit('setLoading', false)
            console.log('Response:', response.data);
  
          })
          .catch(error => {
            commit('setLoading', false)
            console.error('Error:', error);
          });
    },
    async labDelete({ commit }, payload) {
      commit('setLoading', true)
      console.log(localStorage.getItem('admin_access_token'))
      await axios.post(LABS_DELETE_API+payload.id, {}, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
      })  .then(response => {
            commit('setLoading', false)
            console.log('Response:', response.data);
  
          })
          .catch(error => {
            commit('setLoading', false)
            console.error('Error:', error);
          });
    },
    async getAppointmentByIdAgent ({commit,state},payload){
      commit('setLoading', true)
      await axios.post(APPOINTMENT_DETAILS_API+payload.patient_id + '/' + payload.appointment_id, {}, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
    })  .then(response => {
              commit('setLoading', false)
              console.log('Response Notes:', response.data.data);
              commit('setSinglePatientAppointment',response.data.data)
          })
          .catch(error => {
            commit('setLoading', false)
            console.error('Error:', error);
          });
    },
    async getPrescriptions ({commit,state},payload){
      commit('setLoading', true)
      await axios.post(MEETING_PRESCREPTIONS_API+payload.patient_id + '/' + payload.appointment_id, {}, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
      })  .then(response => {
      commit('setLoading', false)
      let doctor={}
      let itemsPrescriptions=[]
                for (let data of response.data) {
                  let dataObject = {}
                  dataObject.first_name = data.patient.first_name
                  dataObject.last_name = data.patient.last_name
                  dataObject.gender = data.patient.gender
                  dataObject.dob = data.patient.dob
                  dataObject.patient_address = data.patient.address+' '+ data.patient.city+' '+ data.patient.state +' ' +data.patient.country
                  dataObject.name = data.prescription.name
                  dataObject.brand = data.prescription.brand
                  dataObject.from = data.prescription.from
                  dataObject.direction_quantity = data.prescription.direction_quantity
                  dataObject.dosage = data.prescription.dosage
                  dataObject.quantity = data.prescription.quantity
                  dataObject.refill_quantity = data.prescription.refill_quantity
                  dataObject.actions = ''
                  dataObject.id = data.prescription.id
                  dataObject.comments = data.comments
                  dataObject.direction_one = data.direction_one
                  dataObject.direction_two = data.direction_two
                  dataObject.doctor = data.telemedPro
                  dataObject.status = data.status
                  dataObject.date = data.created_at
                  dataObject.agent_sign = data.telemedPro.name
                  dataObject.medical_license_number = data.telemedPro.medical_license_number
                  itemsPrescriptions.push(dataObject)
                  
                }
              console.log('Response Notes:', response.data);
      
              commit('setPrescription',itemsPrescriptions)
          })
          .catch(error => {
            commit('setLoading', false)
            commit('setPrescription',null)
            console.error('Error:', error);
          });
    },
    async getHistoryPatientNotes ({commit,state},payload){
      commit('setLoading', true)
      await axios.post(MEETING_NOTES_API+payload.patient_id + '/' + payload.appointment_id, {}, {
        headers: {
            'Authorization': `Bearer ${localStorage.getItem('admin_access_token')}`,
        }
    })  .then(response => {
              commit('setLoading', false)
              console.log('Response Notes:', response.data.data);
              commit('setPatientNotes',response.data.data)
          })
          .catch(error => {
            commit('setLoading', false)
            console.error('Error:', error);
          });
    },
  },
  getters: {
    getIsLoading(state){
      return state.isLoading
    },
    getPatientList(state){
      return state.patientList
    },
    getPatientMeetingList(state){
      return state.patientMeetingList
    },
    
    getProvidersList(state){
      return state.providersList
    },
    getLabsList(state){
      return state.labsList
    },
    getSinglePatientAppointment(state){
      return state.singlePatientAppointment
    },
    getPrescriptionList(state){
      return state.patientPrescription
    },
    getPatientNotes(state){
      return state.patientNotes
    },
  }
})