// server.js
const { ApolloServer, gql } = require('apollo-server');
const { v4: uuidv4 } = require('uuid');

// 模拟数据库
const db = {
  users: [
    {
      id: '1',
      name: 'John Doe',
      email: 'john@example.com',
      age: 30,
      role: 'ADMIN',
      createdAt: '2023-01-01T00:00:00Z',
      posts: ['1', '2'],
    },
    {
      id: '2',
      name: 'Jane Smith',
      email: 'jane@example.com',
      age: 25,
      role: 'USER',
      createdAt: '2023-02-01T00:00:00Z',
      posts: ['3'],
    },
  ],
  posts: [
    {
      id: '1',
      title: 'Hello World',
      content: 'This is my first post',
      author: '1',
      publishedAt: '2023-01-15T00:00:00Z',
      comments: ['1'],
    },
    {
      id: '2',
      title: 'GraphQL Basics',
      content: 'Learn GraphQL fundamentals',
      author: '1',
      publishedAt: '2023-01-20T00:00:00Z',
      comments: [],
    },
    {
      id: '3',
      title: 'React & GraphQL',
      content: 'Integrating React with GraphQL',
      author: '2',
      publishedAt: '2023-02-10T00:00:00Z',
      comments: ['2'],
    },
  ],
  comments: [
    {
      id: '1',
      text: 'Great post!',
      author: '2',
      post: '1',
      createdAt: '2023-01-16T00:00:00Z',
    },
    {
      id: '2',
      text: 'Very helpful, thanks!',
      author: '1',
      post: '3',
      createdAt: '2023-02-11T00:00:00Z',
    },
  ],
};

// 定义Schema
const typeDefs = gql`
  type UserRole {
    ADMIN
    USER
    GUEST
  }

  scalar DateTime

  type User {
    id: ID!
    name: String!
    email: String!
    age: Int
    role: UserRole!
    createdAt: DateTime!
    posts: [Post!]!
    friends: [User!]!
  }

  type Post {
    id: ID!
    title: String!
    content: String!
    author: User!
    publishedAt: DateTime!
    comments: [Comment!]!
  }

  type Comment {
    id: ID!
    text: String!
    author: User!
    post: Post!
    createdAt: DateTime!
  }

  type Query {
    user(id: ID!): User
    users: [User!]!
    post(id: ID!): Post
    posts: [Post!]!
    comment(id: ID!): Comment
    comments: [Comment!]!
  }

  type Mutation {
    createUser(name: String!, email: String!, age: Int): User
    updateUser(id: ID!, name: String, email: String, age: Int): User
    deleteUser(id: ID!): User
    createPost(title: String!, content: String!, authorId: ID!): Post
    updatePost(id: ID!, title: String, content: String): Post
    deletePost(id: ID!): Post
    createComment(text: String!, authorId: ID!, postId: ID!): Comment
  }

  type Subscription {
    newUser: User!
    newPost: Post!
    newComment: Comment!
  }
`;

// Resolvers
const resolvers = {
  Query: {
    user: (parent, { id }, context) => {
      return db.users.find(user => user.id === id);
    },
    users: () => db.users,
    post: (parent, { id }) => {
      return db.posts.find(post => post.id === id);
    },
    posts: () => db.posts,
    comment: (parent, { id }) => {
      return db.comments.find(comment => comment.id === id);
    },
    comments: () => db.comments,
  },

  Mutation: {
    createUser: (parent, { name, email, age }) => {
      const newUser = {
        id: uuidv4(),
        name,
        email,
        age,
        role: 'USER',
        createdAt: new Date().toISOString(),
        posts: [],
      };
      db.users.push(newUser);
      return newUser;
    },
    updateUser: (parent, { id, name, email, age }) => {
      const userIndex = db.users.findIndex(user => user.id === id);
      if (userIndex !== -1) {
        db.users[userIndex] = {
          ...db.users[userIndex],
          name: name || db.users[userIndex].name,
          email: email || db.users[userIndex].email,
          age: age !== undefined ? age : db.users[userIndex].age,
        };
        return db.users[userIndex];
      }
      return null;
    },
    deleteUser: (parent, { id }) => {
      const userIndex = db.users.findIndex(user => user.id === id);
      if (userIndex !== -1) {
        const deletedUser = db.users.splice(userIndex, 1)[0];
        return deletedUser;
      }
      return null;
    },
    createPost: (parent, { title, content, authorId }) => {
      const newPost = {
        id: uuidv4(),
        title,
        content,
        author: authorId,
        publishedAt: new Date().toISOString(),
        comments: [],
      };
      db.posts.push(newPost);
      
      // 更新用户的posts列表
      const user = db.users.find(u => u.id === authorId);
      if (user) {
        user.posts.push(newPost.id);
      }
      
      return newPost;
    },
    updatePost: (parent, { id, title, content }) => {
      const postIndex = db.posts.findIndex(post => post.id === id);
      if (postIndex !== -1) {
        db.posts[postIndex] = {
          ...db.posts[postIndex],
          title: title || db.posts[postIndex].title,
          content: content || db.posts[postIndex].content,
        };
        return db.posts[postIndex];
      }
      return null;
    },
    deletePost: (parent, { id }) => {
      const postIndex = db.posts.findIndex(post => post.id === id);
      if (postIndex !== -1) {
        const deletedPost = db.posts.splice(postIndex, 1)[0];
        
        // 从用户的posts列表中移除
        db.users.forEach(user => {
          user.posts = user.posts.filter(postId => postId !== id);
        });
        
        return deletedPost;
      }
      return null;
    },
    createComment: (parent, { text, authorId, postId }) => {
      const newComment = {
        id: uuidv4(),
        text,
        author: authorId,
        post: postId,
        createdAt: new Date().toISOString(),
      };
      db.comments.push(newComment);
      
      // 更新帖子的comments列表
      const post = db.posts.find(p => p.id === postId);
      if (post) {
        post.comments.push(newComment.id);
      }
      
      return newComment;
    },
  },

  Subscription: {
    newUser: {
      subscribe: (parent, args, { pubsub }) => {
        return pubsub.asyncIterator('NEW_USER');
      },
    },
    newPost: {
      subscribe: (parent, args, { pubsub }) => {
        return pubsub.asyncIterator('NEW_POST');
      },
    },
    newComment: {
      subscribe: (parent, args, { pubsub }) => {
        return pubsub.asyncIterator('NEW_COMMENT');
      },
    },
  },

  User: {
    posts: (parent) => {
      return parent.posts.map(postId => 
        db.posts.find(p => p.id === postId)
      );
    },
    friends: (parent) => {
      // 简化实现，返回所有其他用户作为朋友
      return db.users.filter(user => user.id !== parent.id);
    },
  },

  Post: {
    author: (parent) => {
      return db.users.find(user => user.id === parent.author);
    },
    comments: (parent) => {
      return parent.comments.map(commentId => 
        db.comments.find(c => c.id === commentId)
      );
    },
  },

  Comment: {
    author: (parent) => {
      return db.users.find(user => user.id === parent.author);
    },
    post: (parent) => {
      return db.posts.find(post => post.id === parent.post);
    },
  },
};

// 创建服务器
const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: ({ req }) => {
    // 在这里添加认证逻辑
    return {
      user: req.headers.user, // 示例：从headers获取用户信息
    };
  },
});

// 启动服务器
server.listen().then(({ url }) => {
  console.log(`Server ready at ${url}`);
});

// yoga-server.js
import { createServer } from '@graphql-yoga/node';
import { PubSub } from 'graphql-subscriptions';

const pubsub = new PubSub();

// 模拟数据库
const db = {
  users: [
    {
      id: '1',
      name: 'John Doe',
      email: 'john@example.com',
      role: 'ADMIN',
    },
    {
      id: '2',
      name: 'Jane Smith',
      email: 'jane@example.com',
      role: 'USER',
    },
  ],
};

// 定义Schema
const typeDefs = `
  type User {
    id: ID!
    name: String!
    email: String!
    role: String!
  }

  type Query {
    users: [User!]!
    user(id: ID!): User
  }

  type Mutation {
    createUser(name: String!, email: String!): User
  }

  type Subscription {
    newUser: User!
  }
`;

// Resolvers
const resolvers = {
  Query: {
    users: () => db.users,
    user: (parent, { id }) => {
      return db.users.find(user => user.id === id);
    },
  },

  Mutation: {
    createUser: (parent, { name, email }) => {
      const newUser = {
        id: String(db.users.length + 1),
        name,
        email,
        role: 'USER',
      };
      db.users.push(newUser);
      
      // 发布订阅事件
      pubsub.publish('NEW_USER', { newUser });
      
      return newUser;
    },
  },

  Subscription: {
    newUser: {
      subscribe: () => pubsub.asyncIterator(['NEW_USER']),
    },
  },
};

// 创建服务器
const server = createServer({
  schema: {
    typeDefs,
    resolvers,
  },
  // 添加中间件
  middleware: [
    (request, response, next) => {
      console.log('Request received:', request.request.body);
      next();
    },
  ],
});

// 启动服务器
server.start().then(() => {
  console.log('Server is running on http://localhost:4000');
});

// 服务器端
const typeDefs = `
  type User {
    id: ID!
    name: String!
    email: String!
  }

  type Post {
    id: ID!
    title: String!
    content: String!
    author: User!
  }

  type Comment {
    id: ID!
    text: String!
    author: User!
    post: Post!
  }

  type Query {
    users: [User!]!
    posts: [Post!]!
    comments: [Comment!]!
  }

  type Mutation {
    createUser(name: String!, email: String!): User
    createPost(title: String!, content: String!, authorId: ID!): Post
    createComment(text: String!, authorId: ID!, postId: ID!): Comment
  }

  type Subscription {
    newUser: User!
    newPost: Post!
    newComment: Comment!
  }
`;

const resolvers = {
  Subscription: {
    newUser: {
      subscribe: () => pubsub.asyncIterator(['NEW_USER']),
    },
    newPost: {
      subscribe: () => pubsub.asyncIterator(['NEW_POST']),
    },
    newComment: {
      subscribe: () => pubsub.asyncIterator(['NEW_COMMENT']),
    },
  },
};

// 服务器端Resolver
const resolvers = {
  Query: {
    posts: (parent, { first, after, filter }) => {
      let filteredPosts = [...db.posts];
      
      // 应用过滤
      if (filter) {
        filteredPosts = filteredPosts.filter(post => {
          if (filter.authorId && post.author !== filter.authorId) {
            return false;
          }
          if (filter.search) {
            const searchLower = filter.search.toLowerCase();
            return (
              post.title.toLowerCase().includes(searchLower) ||
              post.content.toLowerCase().includes(searchLower)
            );
          }
          return true;
        });
      }
      
      // 排序
      filteredPosts.sort((a, b) => 
        new Date(b.publishedAt) - new Date(a.publishedAt)
      );
      
      // 分页
      const totalCount = filteredPosts.length;
      const cursorIndex = after ? 
        filteredPosts.findIndex(p => p.id === after) + 1 : 0;
      
      const posts = filteredPosts.slice(cursorIndex, cursorIndex + first);
      
      // 创建edges和pageInfo
      const edges = posts.map(post => ({
        node: post,
        cursor: post.id,
      }));
      
      const hasNextPage = cursorIndex + first < totalCount;
      const hasPreviousPage = cursorIndex > 0;
      
      return {
        edges,
        pageInfo: {
          hasNextPage,
          hasPreviousPage,
          startCursor: edges[0]?.cursor,
          endCursor: edges[edges.length - 1]?.cursor,
        },
        totalCount,
      };
    },
  },
};

// 服务器端优化
const resolvers = {
  Query: {
    // 使用 DataLoader减少数据库查询
    user: async (parent, { id }, { dataloaders }) => {
      return dataloaders.user.load(id);
    },
    
    // 批量查询
    users: async (parent, { ids }, { dataloaders }) => {
      return dataloaders.users.loadMany(ids);
    },
    
    // 使用缓存
    popularPosts: async (parent, args, { redis }) => {
      const cacheKey = 'popular-posts';
      const cached = await redis.get(cacheKey);
      
      if (cached) {
        return JSON.parse(cached);
      }
      
      const posts = await getPopularPosts();
      await redis.setex(cacheKey, 3600, JSON.stringify(posts));
      
      return posts;
    },
  },
};

// DataLoader创建
const dataloaders = {
  user: new DataLoader(async (ids) => {
    const users = await User.find({ _id: { $in: ids } });
    return ids.map(id => users.find(user => user.id === id));
  }),
  
  users: new DataLoader(async (ids) => {
    const users = await User.find({ _id: { $in: ids } });
    return ids.map(id => users.find(user => user.id === id));
  }),
};

// 客户端缓存策略
const client = new ApolloClient({
  uri: 'http://localhost:4000/graphql',
  cache: new InMemoryCache({
    typePolicies: {
      Query: {
        fields: {
          posts: {
            merge(existing = [], incoming) {
              // 自定义合并策略
              const merged = [...incoming];
              const incomingIds = incoming.map(p => p.id);
              const existingToAdd = existing.filter(p => !incomingIds.includes(p.id));
              return [...merged, ...existingToAdd];
            },
          },
        },
      },
    },
  }),
});

// 认证和授权中间件
const authMiddleware = async ({ req, res, next }) => {
  const token = req.headers.authorization || '';
  
  try {
    const { userId } = verifyToken(token);
    const user = await User.findById(userId);
    
    if (!user) {
      throw new Error('User not found');
    }
    
    req.user = user;
    next();
  } catch (error) {
    throw new AuthenticationError('Invalid token');
  }
};

// GraphQL Shield
const { rule, shield } = require('graphql-shield');

const isAuthenticated = rule()((parent, args, ctx) => {
  return ctx.user !== null;
});

const isAdmin = rule()((parent, args, ctx) => {
  return ctx.user && ctx.user.role === 'ADMIN';
});

const permissions = shield({
  Query: {
    users: isAdmin,
    posts: isAuthenticated,
  },
  Mutation: {
    createUser: isAdmin,
    createPost: isAuthenticated,
    deletePost: isAdmin,
  },
});

// 速率限制
const rateLimit = require('express-rate-limit');

const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15分钟
  max: 100, // 限制每个IP 15分钟内最多100个请求
  message: 'Too many requests from this IP',
});

// 输入验证
const { GraphQLNonNull, GraphQLString } = require('graphql');

const validateEmail = (email) => {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
};

const validatePassword = (password) => {
  return password.length >= 8;
};

const UserInput = new GraphQLInputObjectType({
  name: 'UserInput',
  fields: {
    email: {
      type: new GraphQLNonNull(GraphQLString),
      validate: (email) => {
        if (!validateEmail(email)) {
          throw new Error('Invalid email format');
        }
      },
    },
    password: {
      type: new GraphQLNonNull(GraphQLString),
      validate: (password) => {
        if (!validatePassword(password)) {
          throw new Error('Password must be at least 8 characters');
        }
      },
    },
  },
});