import { PrismaClient, Prisma } from '../prisma-generated/client';
import {
  account_user, 
  account_user_uniqueKey, 
  account_user_without_PKs, 
  delivery_order, 
  delivery_order_status_history, 
  delivery_order_status_history_uniqueKey, 
  delivery_order_status_history_without_PKs, 
  delivery_order_uniqueKey, 
  delivery_order_without_PKs, 
  filtered_account_user, 
  filtered_delivery_order, 
  filtered_delivery_order_status_history,
  Entities
} from './entities.type';

export const prisma = new PrismaClient();

export const default_entities: Entities = {
  account_user: {
    /**
        * 创建account_user记录
        * @param data 包含所有字段的数据 (包括手动设置的主键)
        * @returns 创建的记录或null
        */
        Create: async (data: account_user): Promise<account_user | null> => {
            try {
                return await prisma.account_user.create({
                    data: data 
                });
            } catch (error) {
                console.error(`Error creating account_user:`, error);
                return null;
            }
        },

    /**
        * 根据主键获取记录
        * @param args 主键参数
        * @returns 记录或null
        */
        Get: async (args: account_user_uniqueKey): Promise<account_user | null> => {
            try {
                return await prisma.account_user.findUnique({
                    where: { id: args.id },
                });
            } catch (error) {
                console.error(`Error getting account_user:`, error);
                return null;
            }
        },

    /**
        * 获取所有记录
        * @param args 可选筛选条件 (类型: filtered_account_user)
        * @returns 记录数组
        */
        GetAll: async (args?: filtered_account_user): Promise<account_user[]> => {
            try {
                return await prisma.account_user.findMany({
                    where: args as any, 
                });
            } catch (error) {
                console.error(`Error getting all account_user:`, error);
                return [];
            }
        },

    /**
        * 分页获取记录
        * @param pageNumber 页码 (默认 1)
        * @param pageSize 每页大小 (默认 10)
        * @param args 可选筛选条件 (类型: filtered_account_user)
        * @returns 分页记录数组
        */
        GetPage: async (
            pageNumber: number = 1,
            pageSize: number = 10,
            args?: filtered_account_user
        ): Promise<account_user[]> => {
            try {
                const skip = (pageNumber - 1) * pageSize;
                return await prisma.account_user.findMany({
                    where: args as any, 
                    skip,
                    take: pageSize,
                });
            } catch (error) {
                console.error(`Error getting paged account_user:`, error);
                return [];
            }
        },

    /**
        * 统计记录数
        * @param args 可选筛选条件 (类型: filtered_account_user)
        * @returns 记录数量
        */
        Count: async (args?: filtered_account_user): Promise<number> => {
            try {
                return await prisma.account_user.count({
                    where: args as any, 
                });
            } catch (error) {
                console.error(`Error counting account_user:`, error);
                return 0;
            }
        },

    /**
        * 更新记录
        * @param args 包含主键 (where) 和更新数据 (data)
        * @returns 更新后的记录或null
        */
        Update: async (args: { where: account_user_uniqueKey; data: account_user_without_PKs }): Promise<account_user | null> => {
            try {
                return await prisma.account_user.update({
                    where: { id: args.where.id },
                    data: args.data 
                });
            } catch (error) {
                console.error(`Error updating account_user:`, error);
                return null;
            }
        },

    /**
        * 删除记录
        * @param args 主键参数
        * @returns 删除的记录或null
        */
        Delete: async (args: account_user_uniqueKey): Promise<account_user | null> => {
            try {
                return await prisma.account_user.delete({
                    where: { id: args.id },
                });
            } catch (error) {
                console.error(`Error deleting account_user:`, error);
                return null;
            }
        },  },
  delivery_order: {
    /**
        * 创建delivery_order记录
        * @param data 包含所有字段的数据 (包括手动设置的主键)
        * @returns 创建的记录或null
        */
        Create: async (data: delivery_order): Promise<delivery_order | null> => {
            try {
                return await prisma.delivery_order.create({
                    data: data 
                });
            } catch (error) {
                console.error(`Error creating delivery_order:`, error);
                return null;
            }
        },

    /**
        * 根据主键获取记录
        * @param args 主键参数
        * @returns 记录或null
        */
        Get: async (args: delivery_order_uniqueKey): Promise<delivery_order | null> => {
            try {
                return await prisma.delivery_order.findUnique({
                    where: { id: args.id },
                });
            } catch (error) {
                console.error(`Error getting delivery_order:`, error);
                return null;
            }
        },

    /**
        * 获取所有记录
        * @param args 可选筛选条件 (类型: filtered_delivery_order)
        * @returns 记录数组
        */
        GetAll: async (args?: filtered_delivery_order): Promise<delivery_order[]> => {
            try {
                return await prisma.delivery_order.findMany({
                    where: args as any, 
                });
            } catch (error) {
                console.error(`Error getting all delivery_order:`, error);
                return [];
            }
        },

    /**
        * 分页获取记录
        * @param pageNumber 页码 (默认 1)
        * @param pageSize 每页大小 (默认 10)
        * @param args 可选筛选条件 (类型: filtered_delivery_order)
        * @returns 分页记录数组
        */
        GetPage: async (
            pageNumber: number = 1,
            pageSize: number = 10,
            args?: filtered_delivery_order
        ): Promise<delivery_order[]> => {
            try {
                const skip = (pageNumber - 1) * pageSize;
                return await prisma.delivery_order.findMany({
                    where: args as any, 
                    skip,
                    take: pageSize,
                });
            } catch (error) {
                console.error(`Error getting paged delivery_order:`, error);
                return [];
            }
        },

    /**
        * 统计记录数
        * @param args 可选筛选条件 (类型: filtered_delivery_order)
        * @returns 记录数量
        */
        Count: async (args?: filtered_delivery_order): Promise<number> => {
            try {
                return await prisma.delivery_order.count({
                    where: args as any, 
                });
            } catch (error) {
                console.error(`Error counting delivery_order:`, error);
                return 0;
            }
        },

    /**
        * 更新记录
        * @param args 包含主键 (where) 和更新数据 (data)
        * @returns 更新后的记录或null
        */
        Update: async (args: { where: delivery_order_uniqueKey; data: delivery_order_without_PKs }): Promise<delivery_order | null> => {
            try {
                return await prisma.delivery_order.update({
                    where: { id: args.where.id },
                    data: args.data 
                });
            } catch (error) {
                console.error(`Error updating delivery_order:`, error);
                return null;
            }
        },

    /**
        * 删除记录
        * @param args 主键参数
        * @returns 删除的记录或null
        */
        Delete: async (args: delivery_order_uniqueKey): Promise<delivery_order | null> => {
            try {
                return await prisma.delivery_order.delete({
                    where: { id: args.id },
                });
            } catch (error) {
                console.error(`Error deleting delivery_order:`, error);
                return null;
            }
        },  },
  delivery_order_status_history: {
    /**
        * 创建delivery_order_status_history记录
        * @param data 包含所有字段的数据 (包括手动设置的主键)
        * @returns 创建的记录或null
        */
        Create: async (data: delivery_order_status_history): Promise<delivery_order_status_history | null> => {
            try {
                return await prisma.delivery_order_status_history.create({
                    data: data 
                });
            } catch (error) {
                console.error(`Error creating delivery_order_status_history:`, error);
                return null;
            }
        },

    /**
        * 根据主键获取记录
        * @param args 主键参数
        * @returns 记录或null
        */
        Get: async (args: delivery_order_status_history_uniqueKey): Promise<delivery_order_status_history | null> => {
            try {
                return await prisma.delivery_order_status_history.findUnique({
                    where: { id: args.id },
                });
            } catch (error) {
                console.error(`Error getting delivery_order_status_history:`, error);
                return null;
            }
        },

    /**
        * 获取所有记录
        * @param args 可选筛选条件 (类型: filtered_delivery_order_status_history)
        * @returns 记录数组
        */
        GetAll: async (args?: filtered_delivery_order_status_history): Promise<delivery_order_status_history[]> => {
            try {
                return await prisma.delivery_order_status_history.findMany({
                    where: args as any, 
                });
            } catch (error) {
                console.error(`Error getting all delivery_order_status_history:`, error);
                return [];
            }
        },

    /**
        * 分页获取记录
        * @param pageNumber 页码 (默认 1)
        * @param pageSize 每页大小 (默认 10)
        * @param args 可选筛选条件 (类型: filtered_delivery_order_status_history)
        * @returns 分页记录数组
        */
        GetPage: async (
            pageNumber: number = 1,
            pageSize: number = 10,
            args?: filtered_delivery_order_status_history
        ): Promise<delivery_order_status_history[]> => {
            try {
                const skip = (pageNumber - 1) * pageSize;
                return await prisma.delivery_order_status_history.findMany({
                    where: args as any, 
                    skip,
                    take: pageSize,
                });
            } catch (error) {
                console.error(`Error getting paged delivery_order_status_history:`, error);
                return [];
            }
        },

    /**
        * 统计记录数
        * @param args 可选筛选条件 (类型: filtered_delivery_order_status_history)
        * @returns 记录数量
        */
        Count: async (args?: filtered_delivery_order_status_history): Promise<number> => {
            try {
                return await prisma.delivery_order_status_history.count({
                    where: args as any, 
                });
            } catch (error) {
                console.error(`Error counting delivery_order_status_history:`, error);
                return 0;
            }
        },

    /**
        * 更新记录
        * @param args 包含主键 (where) 和更新数据 (data)
        * @returns 更新后的记录或null
        */
        Update: async (args: { where: delivery_order_status_history_uniqueKey; data: delivery_order_status_history_without_PKs }): Promise<delivery_order_status_history | null> => {
            try {
                return await prisma.delivery_order_status_history.update({
                    where: { id: args.where.id },
                    data: args.data 
                });
            } catch (error) {
                console.error(`Error updating delivery_order_status_history:`, error);
                return null;
            }
        },

    /**
        * 删除记录
        * @param args 主键参数
        * @returns 删除的记录或null
        */
        Delete: async (args: delivery_order_status_history_uniqueKey): Promise<delivery_order_status_history | null> => {
            try {
                return await prisma.delivery_order_status_history.delete({
                    where: { id: args.id },
                });
            } catch (error) {
                console.error(`Error deleting delivery_order_status_history:`, error);
                return null;
            }
        },  },
};