import { useUserStore } from '../../stores/piniaStores'
import { storeToRefs } from 'pinia';

const userStore = useUserStore();
const {nickName} = storeToRefs(userStore);

import { createPinia } from 'pinia'
import piniaPluginPersistedstate from 'pinia-plugin-persistedstate'

const pinia = createPinia()
pinia.use(piniaPluginPersistedstate)

import { createSSRApp } from "vue";
import App from "./App.vue";
import * as Pinia from 'pinia';
import piniaPluginPersistedstate from 'pinia-plugin-persistedstate'

export function createApp() {
  const app = createSSRApp(App);
  const pinia = Pinia.createPinia();
  pinia.use(piniaPluginPersistedstate);
  app.use(pinia);
    
  return {
    app,
    Pinia,
  };
}

import { defineStore } from 'pinia'
import { StorageLike } from 'pinia-plugin-persistedstate';
import { ref } from 'vue'


const uniStorege: StorageLike = {
    setItem(key, value) {
        uni.setStorageSync(key, value);
    },
    getItem(key) {
        return uni.getStorageSync(key);
    },
}

// 你可以对 `defineStore()` 的返回值进行任意命名，但最好使用 store 的名字，同时以 `use` 开头且以 `Store` 结尾。(比如 `useUserStore`，`useCartStore`，`useProductStore`)
// 第一个参数是你的应用中 Store 的唯一 ID。
export const useUserStore = defineStore('user', () => {
    const nickName = ref("Kahvia");

    function setName(name: string) {
        nickName.value = name;
    }

    return { nickName, setName };
}, {
    persist: {
        storage: uniStorege,
    },
})

//utils/http.ts
import { useUserStore } from "@/stores/piniaStores";


const baseUrl: string = "https://www.kahvia.cn";

const httpInterceptor = {
    invoke(options: UniApp.RequestOptions) {
        //请求添加前缀
        if (!options.url.startsWith("http"))
            options.url = baseUrl + options.url;
        //设置超时时间
        options.timeout = 10000;
        //设置请求头
        options.header = {
            //保留原有请求头
            ...options.header,
            //添加请求来源
            'source-client': 'miniapp'
        };
        const userStore = useUserStore();
        const token = userStore.profile?.token;
        if (token)
            options.header.Authorization = token;

    },
}

uni.addInterceptor("request", httpInterceptor);
uni.addInterceptor("uploadFile", httpInterceptor);

//utils/http.ts
//接上个拦截器代码块

//自己封装的数据类型
interface Data<T> {
    code: number,
    msg: string,
    data: T
}

//封装uni-request，对数据结果进行统一处理，即拦截请求结果。上面的interceptor是请求发送前拦截。
export const http = <T>(options: UniApp.RequestOptions) => {
    return new Promise<Data<T>>((resolve, reject) => {
        uni.request({
            ...options,
            //服务器有响应结果，不管状态码是200还是401亦或是500，都会走success函数。
            success(res) {
                //状态码正常，则resolve，axios内部也是如此实现的。
                if (res.statusCode >= 200 && res.statusCode < 300) {
                    //用as对返回类型进行断言
                    resolve(res.data as Data<T>);
                } else if (res.statusCode == 401) {
                    //401代表token无效，身份验证失败
                    console.log("Authorization error");
                    uni.showToast({ title: "身份验证失效，请重新登录" });
                    reject(res);
                } else {
                    uni.showToast({ title: "服务器异常" });
                    reject(res);
                }
            },
            //服务器没有返回结果，代表请求未成功发送，即网络异常。
            fail(err) {
                uni.showToast({ title: "网络异常，请检查网络" })
                reject(err);
            },
        })
    })
}

import {http} from '@/utils/http'

async function clickTest(){
    userStore.setName("Adong");
    const res = await http<string[]>({
      method:"GET",
      url:"/test"
    })
    console.log(res);
}