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

export default  {
   namespaced: true,
   state: {
      search: '',
      search_status:0,
      search_error_message:'',
      tests: [],
      total_test: 0,
      selected_test: [],
      exist_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: []
   },
   mutations: {
      update_exist_selected_test(state,val) {
         state.exist_selected_test = 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
      }
   },
   actions: {
      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 tests = context.state.tests
         if (tests == undefined ) tests = []
         tests.push(test)

         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
         for (let i in req) {
            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)
         }

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

      // update_req(context, px) {
         
      //    let reqs = []
      //    let tests = context.state.selected_test
      //    tests.forEach( function(t) {
      //       let label = t.T_TestRequirement
      //       if (_.indexOf(reqs,label) == -1 ) reqs.push(label)
      //    })

      //    let panels = context.state.selected_panel
      //    panels.forEach( function(p) {
      //       let tests = p.test
      //       tests.forEach( function(t) {
      //          let label = t.T_TestRequirement
      //          if (_.indexOf(reqs,label) == -1 ) reqs.push(label)
      //       })
      //    })

      //    let requirement = context.state.requirement
      //    let flag_update_requirement = false
      //    if (reqs.length == 0 ) {
      //       requirement = []
      //       flag_update_requirement = true
      //    }
      //    requirement.forEach(function(r,idx) {
      //       if ( _.indexOf(reqs,r.label) == -1) {
      //          flag_update_requirement = true
      //          requirement.splice(idx,1)
      //       }
      //    })
         
      //    if (flag_update_requirement) {
      //       context.commit('update_requirement', requirement)
      //    }
         
      // },

      async search(context, prm) {
         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 resp= await api.search(mouCompanyID,context.state.search)
            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
               }
               console.log(context.state.exist_selected_test)
               context.commit("update_tests",data)
               var exist_tests = context.state.exist_selected_test
               
               if(exist_tests.length > 0){
                  exist_tests.forEach(function(px,xidx) {
                     if (px.px_type !== "PR" && px.px_type !== "PXR"){
                        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) {
                           alert('Pemeriksaan tersebut sudah ada !')
                           return
                        }

                        let selected_test = context.state.selected_test
                        selected_test.push(px)
                        let tests = context.state.tests
                        let p_idx = -1
                        tests.forEach(function(t,idx) {
                           if (t.T_TestID == px.T_TestID) {
                              p_idx = idx
                           }
                        })
                        if (p_idx >= 0 ) {
                           _.pullAt(tests,[p_idx]) 
                           let dt = {
                              records: tests,
                              total: tests.length
                           }
                           context.commit('update_tests',dt)
                        }
                        context.commit('update_selected_test',selected_test)

                        let req = px.requirement
                        console.log(req)
                        let reqs = context.state.requirement
                        console.log(reqs)
                        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.dispatch('appx_schedule')
                        if(xidx === ( exist_tests.length - 1)){
                           context.commit('update_exist_selected_test',[])
                        }
                     }else{
                        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) {
                           alert('Error')
                           return
                        }

                        let pxs = px.child_test
                        
                        for (let i in pxs) {
                           px = pxs[i]
                           
                           let selected_test = context.state.selected_test
                           let flag_found = false

                           selected_test.push(px)
                           let tests = context.state.tests
                           let p_idx = -1
                           tests.forEach(function(t,idx) {
                              if (t.T_TestID == px.T_TestID) {
                                 p_idx = idx
                              }
                           })
                           
                           if (p_idx >= 0 ) {
                              _.pullAt(tests,[p_idx]) 
                              let dt = {
                                 records: tests,
                                 total: tests.length
                              }
                              context.commit('update_tests',dt)
                           }
                           
                           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.dispatch('appx_schedule')
                           }
                        }
                     }
                  })
                  
               }
            }
         } 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
               for (let i in x) {
                  if (x[i].T_TestID == prm.test_id) {
                     if (Math.round(resp.data.test_price) == 0) {
                        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)

                        let tests = context.state.tests
                        if (tests == undefined ) tests = []
                        tests.push(x[i])
                        let dt = {
                           records : tests,
                           total: tests.length
                        }
                        context.commit("update_tests", dt)
                        x.splice(i, 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_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 )
            
         }
      }
   }
}