// 1 => LOADING
// 2 => DONE
// 3 => ERROR
import * as api from "../api/px.js"

export default  {
   namespaced: true,
   state: {
      search: '',
      search_token: {},
      search_status:0,
      search_error_message:'',
      tests: [],
      total_test: 0,
      selected_test: [],

      search_panel: '',
      search_panel_status:0,
      panels: [],
      total_panel: 0,
      selected_panel: [],
      requirement: [],
      appx_schedule: '',

      search_profile: '',
      profiles: [],
      total_profile: 0,

      cito: {test:[], panel:[]},
      nat_test: [],

      req_status: "X",
      reqs: [],

      citos: [],
      selected_cito: null,
      is_cito: "N"
   },
   mutations: {
      update_search_token(state, val) {
         state.search_token = val
      },
      update_requirement(state,val) {
         state.requirement = val
      },
      update_search_error_message(state,status) {
         state.search_error_message = status
      },
      update_selected_test(state,val) {
         // if (state.cito.length > 0) {
            for (var i in val) {
               val[i]['T_TestIsCito'] = 'N'
               if (state.cito.test.indexOf(val[i]['T_TestID']) > -1)
                  val[i]['T_TestIsCito'] = 'Y'
            }
         // }

         state.selected_test = val
      },
      update_mouCompanyID(state,val) {
         state.mouCompanyID=val 
      },
      update_search(state,val) {
         state.search=val 
      },
      update_search_status(state,status) {
         state.search_status = status
      },
      update_tests(state,data) {
         state.tests= data.records
         state.total_test= data.total
      },
      update_search_panel(state,val) {
         state.search_panel=val 
      },
      update_search_panel_status(state,status) {
         state.search_panel_status = status
      },
      update_panels(state,data) {
         state.panels = data.records
         state.total_panel = data.total
      },
      update_selected_panel(state,val) {
         state.selected_panel= val
      },

      update_cito(state, val) {
         let test = state.selected_test
         let cito = state.cito
         // if (val.length > 0) {
            
            for (var i in test) {
               test[i]['T_TestIsCito'] = 'N'
               if (val.v.indexOf(test[i]['T_TestID']) > -1)
                  test[i]['T_TestIsCito'] = 'Y'
            }
            
         // }

         cito[val.t] = val.v
         console.log(cito)
         state.cito = cito
         state.selected_test = test         
      },

      update_appx_schedule(state, v) {
         state.appx_schedule = v
      },

      update_search_profile(state, v) {
         state.search_profile = v
      },

      update_profiles(state, data) {
         state.profiles = data.records
         state.total_profile = data.total
      },

      update_nat_test(state) {
         let px = state.selected_test
         let nt = []
         for (let i in px) {
            for (let j in px[i].nat_test) {
               nt.push(px[i].nat_test[j])
            }
         }

         state.nat_test = nt
      },

      update_req_status(state, val) {
         state.req_status = val
      },

      update_reqs(state, val) {
         state.reqs = val
      },

        update_citos(state, val) {
            state.citos = val.records
        },

        update_selected_cito(state, val) {
            state.selected_cito = val
        },

        update_is_cito(state, val) {
            state.is_cito = val
        }
   },
   actions: {
      async packet_reqs(context,prm) {
         console.log(prm)
         context.commit("update_search_panel_status",1)
         try {
            prm.token = one_token()
            let resp= await api.packet_reqs(prm)
            if (resp.status != "OK") {
               context.commit("update_search_panel_status",3)
               context.commit("update_search_error_message",resp.message)
            } else {
               context.commit("update_search_panel_status",2)
               context.commit("update_search_error_message","")
              
               let req = resp.data
               console.log(req)
               let reqs = context.state.requirement
               if (req.length > 0) {
                  for(let i in req) {
                     let found = false
                     for(let j in reqs) {
                        if (reqs[j]['req_id'] == req[i]['req_id'])
                           found = j
                     }

                     if (!found){
                        reqs.push({
                           px_id: req[i]['tests'],
                           label: req[i]['req_name'],
                           error_message: 'Hasil harus di isi',
                           is_error: true,
                           checked : false,
                           note: '',
                           req_id: req[i]['req_id']
                        })
                     }
                     else{
                        if(req[i]['tests'].length > 0){
                           req[i]['tests'].forEach(function(xtestid) {
                              if(reqs[found].px_id.indexOf(xtestid) == -1)
                                 reqs[found].px_id.push(xtestid)
                           })
                        }
                     }
                        
                  }

                  context.commit('update_requirement', reqs)
                  console.log('selesai paket req')
                  context.commit('order/update_loading_data_patient', true, { root: true })
               }
            }
         } catch(e) {
            context.commit("update_search_panel_status",3)
            context.commit("update_search_error_message",e.message )
         }
      },
      delete_px (context, test) {
         let sel = context.state.selected_test
         sel.forEach(function(t, idx) {
            if(t.T_TestID == test.T_TestID && t.px_type == test.px_type) {
               sel.splice(idx,1)
            }
         })
         context.commit("update_selected_test", sel)

         let cito = context.state.cito.test
         if(cito.length > 0){
            let cito_idx = cito.indexOf(test.T_TestID)
            if (cito_idx > -1)
               cito.splice(cito_idx, 1)
         }
         
         let tests = context.state.tests
         if (tests == undefined ) tests = []
         let idx_exist_test = _.findIndex(tests, function(o) { return o.T_TestID == test.T_TestID })
         if(idx_exist_test > -1){
            tests.splice(idx_exist_test, 1)
         }
         tests.push(test)
         

         //context.dispatch("search") 
         let dt = {
            records : tests,
            total: tests.length
         }

         context.commit("update_tests", dt)
         context.dispatch("delete_req", test)
         // context.dispatch("update_req", null)
         context.dispatch("appx_schedule")
         context.commit('update_nat_test')
      },

      delete_req(context, px) {
         let req = context.state.requirement
         if(px.px_type !== 'PN'){
            for (let i = req.length - 1; i >= 0; i-- ) {
               let x = _.indexOf(req[i].px_id, px.T_TestID)
               if (x > -1)
                  req[i].px_id.splice(x, 1)
   
               if (req[i].px_id.length < 1)
                  req.splice(i, 1)
            }
         }
         else{
            px.child_test.forEach(function(entry){
               for (let i = req.length - 1; i >= 0; i-- ) {
                  let x = _.indexOf(req[i].px_id, entry.T_TestID)
                  if (x > -1)
                     req[i].px_id.splice(x, 1)
      
                  if (req[i].px_id.length < 1)
                     req.splice(i, 1)
               }
            })
         }
         

         context.commit('update_requirement', req)
      },

      async search(context) {
            if (!one_token()) {
                context.commit("update_search_status", 3)
                context.commit("update_search_error_message", 'No TOKEN Found')

                context.commit('update_message_error', 'Maaf, koneksi Anda sempat terputus silahkan Log Out dan Login kembali', {root:true})
                context.commit('update_dialog_error', true,  {root:true})
                return
            }

         context.commit("update_search_status",1)
         try {
            let mouCompanyID = 0
            if (context.rootState.company.selected_mou.M_MouID) {
               mouCompanyID = context.rootState.company.selected_mou.M_MouID
            }
            let search_token = context.state.search_token
            if (search_token.hasOwnProperty("token")) {
               console.log('CancelToken', search_token.token)
               search_token.cancel()
            }
            search_token = axios.CancelToken.source()
            context.commit("update_search_token",search_token)
            console.log('CancelToken Start',search_token.token)

            //clear the result 1st
            let data = {
               records : [],
               total: 0
            }
            context.commit("update_tests",data)
            console.log('selesai dari px.js')
            let resp= await api.search(mouCompanyID, context.state.search, search_token.token )
            if (resp.status != "OK") {
               context.commit("update_search_status",3)
               context.commit("update_search_error_message",resp.message)
            } else {
               context.commit("update_search_status",2)
               context.commit("update_search_error_message","")
               let data = {
                  records : resp.data.records,
                  total: resp.data.total
               } 
               /////////////////////////////
               var dadata = []
               var xdata = resp.data.records
               let selected_test = context.state.selected_test
               xdata.forEach( function(t,idx) {
                  if (t.px_type == "PR" ){
                     var xchk = true
                     t.child_test.forEach( function(natx){
                        var idxx =_.findIndex(selected_test, function(o) { return o.T_TestID == natx.T_TestID })
                        if(idxx !== -1){
                           xchk = false
                        }
                     })
                     if(xchk){
                        dadata.push(t)
                     }
                  }
                  else{
                     var idxx =_.findIndex(selected_test, function(o) { return o.T_TestID == t.T_TestID })
                     if(idxx === -1){
                        dadata.push(t)
                     }
                  }
                  
               })
               var newdata = {
                  records : dadata,
                  total: dadata.length
               }
               context.commit("update_tests",newdata)
               
               //////////////////////////////////////////////
            }
            
         } catch(e) {
            context.commit("update_search_status",3)
            context.commit("update_search_error_message",e.message )
            console.log(e)
         }
      },

      async panel(context,prm) {
         context.commit("update_search_panel_status",1)
         try {
            let mouCompanyID = 0
            if (context.rootState.company.selected_mou.M_MouCompanyID) {
               mouCompanyID = context.rootState.company.selected_mou.M_MouCompanyID
            }
            let resp= await api.panel(mouCompanyID,context.state.search)
            if (resp.status != "OK") {
               context.commit("update_search_panel_status",3)
               context.commit("update_search_error_message",resp.message)
            } else {
               context.commit("update_search_panel_status",2)
               context.commit("update_search_error_message","")
               let data = {
                  records : resp.data.records,
                  total: resp.data.total
               }
               context.commit("update_panels",data)
            }
         } catch(e) {
            context.commit("update_search_panel_status",3)
            context.commit("update_search_error_message",e.message )
         }
      },

      async profile(context) {
         context.commit("update_search_panel_status", 1)
         try {
            let mou_id = 0
            if (context.rootState.company.selected_mou.M_MouID) {
               mou_id = context.rootState.company.selected_mou.M_MouID
            }

            let resp = await api.profile(mou_id, context.state.search_profile)
            if (resp.status != "OK") {
               context.commit("update_search_panel_status",3)
               context.commit("update_search_error_message",resp.message)
            } else {
               context.commit("update_search_panel_status",2)
               context.commit("update_search_error_message","")
               let data = {
                  records : resp.data.records,
                  total: resp.data.total
               }
               context.commit("update_profiles", data)
            }
         } catch(e) {
            context.commit("update_search_panel_status",3)
            context.commit("update_search_error_message",e.message )
         }
      },

      async get_price(context, prm) {
         context.commit("update_search_status",1)
         try {
            
            let mou_id = context.rootState.company.selected_mou.M_MouID
            let resp = await api.get_price(prm.test_id, mou_id, prm.cito)

            if (resp.status != "OK") {
               context.commit("update_search_status",3)
               context.commit("update_search_error_message",resp.message)
            } else {
               context.commit("update_search_status",2)
               context.commit("update_search_error_message","")
               
               let x = context.state.selected_test
               console.log("kentut berot")
               console.log(prm.cito)
               for (let i in x) {
                  if (x[i].T_TestID == prm.test_id) {
                     if ((Math.round(resp.data.test_price) == 0 && x[i].T_TestForceSell != "Y") || 
                        Math.round(resp.data.test_price) < 0 ) {
                        alert('Pemeriksaan ini belum ada harga CITO-nya !')
                        console.log(x[i].T_TestName)
                        x[i].T_TestIsCito = "N"
                        let n = context.state.cito.test.indexOf(x[i].T_TestID)
                        if (n > -1)
                           context.state.cito.test.splice(n, 1)
                     }
                     else {
                        x[i].T_PriceAmount = resp.data.test_price
                        x[i].T_PriceDisc = resp.data.test_disc
                        x[i].T_PriceDiscRp = resp.data.test_discrp
                     }
                  }
               }
              // context.commit('update_message_error', 'satu...dua...tiga permen manis rasanya, coba cek agreement sepertinya sudah kadaluarsa', {root:true})
                  //context.commit('update_dialog_error', true,  {root:true})

               context.commit("update_selected_test", x)
               context.commit("update_nat_test")
            }
         } catch(e) {
            context.commit("update_search_status",3)
            context.commit("update_search_error_message",e.message )
            
         }
      },

      async appx_schedule(context) {
         context.commit("update_search_status",1)
         try {
            
            let ids = []
            let pn_ids = []
            context.commit("update_appx_schedule", '-')

            let pxs = context.state.selected_test
            for (let i in pxs) {
                if (pxs[i].px_type == 'PN')
                    pn_ids.push(pxs[i].T_TestID)
                else
                    ids.push(pxs[i].T_TestID)
            }
               
            let resp = await api.appx_schedule(ids.join(','), pn_ids.join(','))

            if (resp.status != "OK") {
               context.commit("update_search_status", 3)
               context.commit("update_search_error_message",resp.message)
            } else {
               context.commit("update_search_status", 2)
               context.commit("update_search_error_message","")
               
               context.commit("update_appx_schedule", resp.data)
            }
         } catch(e) {
            context.commit("update_search_status",3)
            context.commit("update_search_error_message", e.message )
            
         }
      },

        async search_cito(context) {
            context.commit("update_search_status",1)
            try {
                let resp= await api.search_cito(one_token())
                if (resp.status != "OK") {
                    context.commit("update_search_status",3)
                    context.commit("update_search_error_message", resp.message)
                } else {
                    context.commit("update_search_status",2)
                    context.commit("update_search_error_message","")
                    let data = {
                        records : resp.data.records
                    }
                    context.commit("update_citos", data)

                    for (let i in data.records)
                        if (data.records[i].Nat_CitoIsDefault == "Y")
                            context.commit('update_selected_cito', data.records[i])
                }
            } catch(e) {
                context.commit("update_search_status",3)
                context.commit("update_search_error_message", e.message )
            }
        },

        async search_pxs(context, id) {
            context.commit("update_search_status",1)
            // LOADING
            context.commit('update_dialog_loading', true, {root:true})

            try {
               let mouCompanyID = 0
               if (context.rootState.company.selected_mou.M_MouID) {
                  mouCompanyID = context.rootState.company.selected_mou.M_MouID
               }
               let resp= await api.search_pxs(mouCompanyID, id)
               if (resp.status != "OK") {
                  context.commit("update_search_status",3)
                  context.commit("update_search_error_message",resp.message)

                  // LOADING
                  context.commit('update_dialog_loading', false, {root:true})
               } else {
                  context.commit("update_search_status",2)
                  context.commit("update_search_error_message","")
                  
                    let x = resp.data.records
                    
                    for (let k in x) {
                        // SEARCH NAT TEST
                        let px = x[k]
                        let nt = context.state.nat_test
                        let found_nt = false
                        for (let i in px.nat_test) {
                            if (nt.indexOf(px.nat_test[i]) > -1)
                                found_nt = true
                        }

                        if (found_nt)
                            continue

                        let selected_test = context.state.selected_test
                        let flag_found = false
                        selected_test.forEach( function(t, idx) {
                            if (t.T_TestID == px.T_TestID) {
                                selected_test[idx] = px 
                                flag_found = true
                            }
                        })

                        if (!flag_found) {
                            selected_test.push(px)
                        }
                        context.commit('update_selected_test', selected_test)

                        let req = px.requirement
                        let reqs = context.state.requirement
                        if (req.length > 0) {
                            for(let i in req) {
                                let found = false
                                for(let j in reqs) {
                                    if (reqs[j]['req_id'] == req[i]['req_id'])
                                        found = j
                                }

                                if (!found)
                                    reqs.push({
                                        px_id: [px.T_TestID],
                                        label: req[i]['req_name'],
                                        error_message: 'Hasil harus di isi',
                                        is_error: true,
                                        checked : false,
                                        note: '',
                                        req_id: req[i]['req_id']
                                    })
                                else
                                    reqs[found].px_id.push(px.T_TestID)
                            }

                            context.commit('update_requirement', reqs)
                        }

                        
                        context.commit('update_nat_test')
                        // END LOADING
                        
                    }

                    context.dispatch('appx_schedule')
                    context.commit('update_dialog_loading', false, {root:true})
                    context.commit('history/update_history_dialog', false, {root:true})
                    context.commit('change_tab', '02', {root:true})
               }
            } catch(e) {
               context.commit("update_search_status",3)
               context.commit("update_search_error_message",e.message )
               console.log(e)
            }
         },

         async search_pxs_clinic(context, id) {
             context.commit("update_search_status",1)
             // LOADING
             context.commit('update_dialog_loading', true, {root:true})
 
             try {
                let mouCompanyID = 0
                if (context.rootState.company.selected_mou.M_MouID) {
                   mouCompanyID = context.rootState.company.selected_mou.M_MouID
                }
                let resp= await api.search_pxs_clinic(mouCompanyID, id)
                if (resp.status != "OK") {
                   context.commit("update_search_status",3)
                   context.commit("update_search_error_message",resp.message)
 
                   // LOADING
                   context.commit('update_dialog_loading', false, {root:true})
                } else {
                   context.commit("update_search_status",2)
                   context.commit("update_search_error_message","")
                   
                     let x = resp.data.records
                     
                     for (let k in x) {
                         // SEARCH NAT TEST
                         let px = x[k]
                         let nt = context.state.nat_test
                         let found_nt = false
                         for (let i in px.nat_test) {
                             if (nt.indexOf(px.nat_test[i]) > -1)
                                 found_nt = true
                         }
 
                         if (found_nt)
                             continue
 
                         let selected_test = context.state.selected_test
                         let flag_found = false
                         selected_test.forEach( function(t, idx) {
                             if (t.T_TestID == px.T_TestID) {
                                 selected_test[idx] = px 
                                 flag_found = true
                             }
                         })
 
                         if (!flag_found) {
                             selected_test.push(px)
                         }
                         context.commit('update_selected_test', selected_test)
 
                         let req = px.requirement
                         let reqs = context.state.requirement
                         if (req.length > 0) {
                             for(let i in req) {
                                 let found = false
                                 for(let j in reqs) {
                                     if (reqs[j]['req_id'] == req[i]['req_id'])
                                         found = j
                                 }
 
                                 if (!found)
                                     reqs.push({
                                         px_id: [px.T_TestID],
                                         label: req[i]['req_name'],
                                         error_message: 'Hasil harus di isi',
                                         is_error: true,
                                         checked : false,
                                         note: '',
                                         req_id: req[i]['req_id']
                                     })
                                 else
                                     reqs[found].px_id.push(px.T_TestID)
                             }
 
                             context.commit('update_requirement', reqs)
                         }
 
                         
                         context.commit('update_nat_test')
                         // END LOADING
                         
                     }
 
                     context.dispatch('appx_schedule')
                     context.commit('update_dialog_loading', false, {root:true})
                     context.commit('history/update_history_dialog', false, {root:true})
                     context.commit('change_tab', '02', {root:true})
                }
             } catch(e) {
                context.commit("update_search_status",3)
                context.commit("update_search_error_message",e.message )
                console.log(e)
             }
          }
   }
}