import Vue from 'vue'
import Router from 'vue-router'
import store from '@/store'
import NotFound from '@/views/NotFound.vue'
import Login from '@/views/Login/index.vue'
import req from '@/request.js'
//路由
import mainRouter from '@/router/module_router'
import customSystemRouter from '@/router/custom-system-router'
import Layout from '@/components/layout/Layout.vue'
// URL表单路由
import flowformRouter from '@/components/flowURLForm/formRouter.js'
Vue.use(Router)

var router = new Router({
  mode: 'history',
  base: process.env.BASE_URL,
  routes: [
    ...flowformRouter,
    // 重定向到login
    {
      path: '/',
      redirect: {
        name: 'login'
      }
    },
    // 登录页面
    {
      path: '/login',
      name: 'login',
      component: Login,
      meta: {
        single: true,
        anonymous: true
      }
    },
    /* 跳转启动流程 */
    {
      path: '/agentStart/:defId/:leaderId',
      name: 'defStart',
      component: () => import('@/components/flow/start.vue'),
      props: true
    },
    /*复制流程启动 */
    {
      path: '/agentStart/:defId/:leaderId/:copyInstId',
      name: 'defCopyStart',
      component: () => import('@/components/flow/start.vue'),
      props: true
    },
    //根据流程定义key启动流程
    {
      path: '/agentStartByKey/:defKey',
      name: 'defKeyStart',
      component: () => import('@/components/flow/startByKey.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    {
      path: '/sysModulePreview/:id/:appName',
      name: 'sysModulePreview',
      component: () => import('@/components/generator/sysModulePreview.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    {
      path: '/start/:defId/:instId',
      name: 'instStart',
      component: () => import('@/components/flow/start.vue'),
      props: true
    },
     /* 待阅列表跳转 */
     {
      path: '/inst/:instId/:type/:readId',
      name: 'instRead-read',
      component: () => import('@/components/flow/task.vue'),
      props: true
    },
    /* 模块开发代办跳转 */
    {
      path: '/sysModuleInst/:taskId/:leaderId/:defKey/:noSingle',
      name: 'sysModuleInst',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    /* 数据报表模块开发代办跳转 */
    {
      path:
        '/reportModuleInst/:taskId/:leaderId/:defKey/:noSingle/:templateKey',
      name: 'reportModuleInst',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    /* 模块开发已办列表跳转 */
    {
      path: '/sysModuleInst/:instId/:type/:defKey',
      name: 'sysModuleInstJump',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },

    /* 数据报表模块开发已办列表跳转 */
    {
      path: '/reportModuleInstDone/:instId/:type/:defKey/:templateKey',
      name: 'reportModuleInstDone',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    /* 状态为FOLLOW时候模块开发待阅跳转 */
    {
      path: '/sysModuleInstTaskRead/:taskId/:task_state/:defKey',
      name: 'sysModuleInstTaskRead',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    /* 模块开发待阅跳转 */
    {
      path: '/sysModuleInstRead/:instId/:type/:readId/:defKey',
      name: 'sysModuleInstReadJump',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    /* 状态为FOLLOW时候数据报表模块开发待阅跳转 */
    {
      path:
        '/reportModuleInstTaskRead/:taskId/:task_state/:defKey/:templateKey',
      name: 'reportModuleInstTaskRead',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    /* 数据报表模块开发待阅跳转 */
    {
      path: '/reportModuleInstRead/:instId/:type/:readId/:defKey/:templateKey',
      name: 'reportModuleInstRead',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    /* 模块开发已阅列表跳转 */
    {
      path: '/sysModuleInstDone/:instId/:type/:readType/:readDoneId/:defKey',
      name: 'sysModuleInstDone',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    /* 数据报表模块开发已阅列表跳转 */
    {
      path:
        '/reportModuleInstDone/:instId/:type/:readType/:readDoneId/:defKey/:templateKey',
      name: 'reportModuleInstDoneRead',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    /* 模块开发我传阅列表跳转 */
    {
      path: '/sysModuleInstMyRead/:instId/:readId/:myReadType/:defKey',
      name: 'sysModuleInstMyRead',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    /* 数据报表模块开发我传阅列表跳转 */
    {
      path:
        '/reportModuleInstMyRead/:instId/:readId/:myReadType/:defKey/:templateKey',
      name: 'reportModuleInstMyRead',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    //模块开发我传阅的列表跳转
    {
      path: '/sysModuleInstRead/:instId/:myReadType/:defKey',
      name: 'sysModuleInstRead',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    //数据报表模块开发我传阅的列表跳转
    {
      path: '/reportModuleInstRead/:instId/:myReadType/:defKey/:templateKey',
      name: 'reportModuleInstReadJump',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },

    /* 已阅列表跳转 */
    {
      path: '/inst/:instId/:type/:readType/:readDoneId',
      name: 'instRead-done',
      component: () => import('@/components/flow/task.vue'),
      props: true
    },

    /* 我传阅的列表跳转 */
    {
      path: '/myRead/:instId/:readId/:myReadType',
      name: 'myRead-type',
      component: () => import('@/components/flow/task.vue'),
      props: true
    },
    {
      path: '/instRead/:instId/:myReadType',
      name: 'instRead',
      component: () => import('@/components/flow/task.vue'),
      props: true
    },

    {
      path: '/taskRead/:taskId/:task_state',
      name: 'taskRead',
      component: () => import('@/components/flow/task.vue'),
      props: true
    },
    {
      path: '/inst/:instId',
      name: 'defaultInst',
      component: () => import('@/components/flow/task.vue'),
      props: true
    },
    // {
    //   path: '/task/:taskId/:leaderId',
    //   name: 'task',
    //   component: () => import('@/components/flow/task.vue'),
    //   props: true
    // },
    {
      path: '/task/:taskId/:leaderId',
      name: 'task',
      component: () =>
        import('@/components/flow/taskFlowComponents/flowTask.vue'),
      props: true
    },
    /* 跳转任务详情 */
    {
      path: '/inst/:instId/:type',
      name: 'inst',
      component: () =>
        import('@/components/flow/taskFlowComponents/flowTask.vue'),
      props: true
    },
    {
      path: '/task/:taskId/:leaderId/:noSingle',
      name: 'taskNosingle',
      component: () => import('@/components/flow/task.vue'),
      props: true,
      meta: {
        single: true
      }
    },
    // 重置密码
    {
      path: '/resetPwdView',
      name: 'resetPwdViewInner',
      props: true,
      component: () => import('@/views/ResetPwdView.vue')
    },
    // 后台页面
    {
      path: '/platLayout',
      name: 'platLayout',
      component: Layout,
      meta: {
        single: true,
        anonymous: true
      },
      children: [
        // 自定义前台路由
        ...customSystemRouter,
        // 需要在系统菜单中配置的路由
        ...mainRouter
      ]
    },
    // 404页面
    {
      path: '/:catchAll(.*)',
      component: NotFound,
      meta: {
        // single: true
      }
    },

  ]
})


const createRouter = () =>
  new Router({
    mode: 'history',
    routes: []
  })

//重写动态添加路由方法
router.$addRoutes = params => {
  const newRouter = createRouter()
  router.matcher = newRouter.matcher //重置路由规则
  router.addRoutes(params) // 添加路由
}

//动态新增二级路由
router.addList = (path, list) => {
  let isAddPath = false
  let isChildren = false

  return isChildren
}

let registerRouteFresh = true

const ssoRedirect = () => {
  if (window.ssoConfig.mode == 'cas') {
    let service = window.location.href
    localStorage.setItem('service', service)
    window.location.href = window.ssoConfig.url + '?service=' + service
  } else if (window.ssoConfig.mode == 'oauth') {
    if (!window.ssoConfig.clientId) {
      throw 'oauth模式下必须提供clientId'
    }
    const service = window.location.href
    localStorage.setItem('service', service)
    window.location.href = `${window.ssoConfig.url}?response_type=code&client_id=${window.ssoConfig.clientId}&redirect_uri=${service}`
  }
}

const handelShortUrl = (to, from, next) => {
  req
    .get(
      '${portal}/portal/shorturlManage/v1/getLongUrlByShortUrl?shortUrl=' +
      to.fullPath.substr(1),
      '',
      false
    )
    .then(resp => {
      if (resp && resp.data && resp.data.state) {
        store
          .dispatch(
            'login/validAndCompletedCurrent',
            resp.data.value.guestToken
          )
          .then(() => {
            next({
              path: resp.data.value.url
            })
          })
          .catch(() => {
            logoutAndCleanUp(to, from, next)
          })
      } else {
        next({
          path: '/messageFillPage/' + resp.data.message
        })
      }
    })
    .catch(() => {
      logoutAndCleanUp(to, from, next)
    })
}

const logoutAndCleanUp = (to, from, next) => {
  store.dispatch('login/logoutAndCleanUp').then(() => {
    if (window.ssoConfig.mode && window.ssoConfig.mode != 'jwt' && !ticket) {
      ssoRedirect()
    } else if (!window.ssoConfig.mode || window.ssoConfig.mode == 'jwt') {
      next({
        path: '/login'
        // query: {
        //     redirect: to.fullPath
        // }
      })
    } else {
      throw '登录失败'
    }
  })
}

// 移除url后面的指定参数
const removeUrlParams = param => {
  const query = window.location.search.substring(1)
  if (!query) {
    return
  }
  const vars = query.split('&')
  const newVars = []
  for (var i = 0; i < vars.length; i++) {
    var pair = vars[i].split('=')
    if (pair[0] != param) {
      newVars.push(vars[i])
    }
  }
  console.log(newVars)
  setTimeout(() => {
    const path = `${window.location.pathname}${newVars.length > 0 ? '?' : ''
      }${newVars.join('&')}`
    window.history.replaceState(null, null, path)
  }, 1000)
}

router.beforeEach(async (to, from, next) => {
  store.dispatch('menu/actionFrontMenus')

  // console.log(to.name, from.name, 'to,from')
  store.dispatch('menu/getAllmenus', {}).then(menus => {
    //href菜单不进这段代码
    if (to.fullPath.indexOf('href') == -1) {
      let alias = to.fullPath.split('/')[1]
      for (let i = 0; i < menus.length; i++) {
        if (menus[i].alias === alias) {
          store.dispatch('menu/getCurrentMenu', {
            alias: menus[i].alias,
            name: menus[i].name
          })
          break
        }
      }
    }
  })
  if (to.fullPath.startsWith('/surl/')) {
    handelShortUrl(to, from, next)
    return
  }

  // 1.当前为单点登录模式，且要路由到login页面，则做单点登录重定向；
  if (
    to.name == 'login' &&
    window.ssoConfig.mode &&
    window.ssoConfig.mode != 'jwt'
  ) {
    // 单点登录时如果已经携带了code或者ticket时，如果是/login路径需要跳转到默认页面（解决反复跳转的问题）
    if (
      (window.ssoConfig.mode == 'cas' || window.ssoConfig.mode == 'oauth') &&
      (to.query.code || to.query.ticket)
    ) {
      window.location.href = window.location.href.replace('/login', '')
      return
    } else {
      ssoRedirect()
    }
  }

  if (from.name != 'defStart' || to.name != 'instStart') {
    sessionStorage.removeItem('formImportTempRefId')
    sessionStorage.removeItem('formImportTempJson')
  }

  if (
    sessionStorage.menu_alias &&
    to.fullPath &&
    to.fullPath.split('/')[1] == 'home'
  ) {
    sessionStorage.menu_alias = ''
  }
  if (to.matched.some(record => !record.meta.anonymous)) {
    let ticket = to.query.token
    // 2.当前已经从单点页面重定向回来了，且在url地址中携带了ticket或code；
    if (window.ssoConfig.mode == 'cas') {
      ticket = to.query.ticket
    } else if (window.ssoConfig.mode == 'oauth') {
      ticket = to.query.code
    }

    store
      // 3.携带ticket做用户鉴权；
      .dispatch('login/validAndCompletedCurrent', ticket)
      .then(() => {
        store._vm.$root.$emit('login-completed')
        if (registerRouteFresh) {
          if (sessionStorage.menu_alias) {
            let path = '/' + sessionStorage.menu_alias
            let isChildren = router.addList(path, router.options.routes) //动态新增二级路由
            //当前点击菜单的路由别名不存在 router.js 里面
            // if (!isChildren) {
            //   let alias_new = {
            //     path: path,
            //     name: 'alias_new',
            //     component: resolve =>
            //       require(['@/views/menuContent.vue'], resolve),
            //     children: []
            //   }
            //   router.options.routes.push(alias_new)
            //   router.addList(path, router.options.routes) //动态新增二级路由
            // }
            router.replace({
              path: to.path,
              query: to.query
            })
          }
          registerRouteFresh = false
        }
        next()
        // url地址带token的方式认证成功后删除url中的token
        // removeUrlParams('tokenKey')
      })
      .catch(() => {
        // 4.鉴权失败时根据当前模式重定向到对应页面。
        logoutAndCleanUp(to, from, next)
      })
  } else {
    next()
  }
})

export default router