ng-code/backup-original/app/services/auth.service.ts

import { Injectable, inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable, BehaviorSubject, throwError } from 'rxjs';
import { tap, catchError } from 'rxjs/operators';
import { Router } from '@angular/router';
import { LoginRequest, LoginResponse, UserInfo, AuthState } from '../models/auth.model';

@Injectable({
  providedIn: 'root'
})
export class AuthService {
  private http = inject(HttpClient);
  private router = inject(Router);

  private authState = new BehaviorSubject<AuthState>({
    isAuthenticated: false
  });
  authState$ = this.authState.asObservable();

  private readonly TOKEN_KEY = 'auth_token';
  private readonly USER_KEY = 'auth_user';

  constructor() {
    console.log('AuthService初始化 (Token认证)');
    this.initializeAuthState();
  }

  private initializeAuthState() {
    console.log('初始化认证状态');
    const token = this.getToken();
    const user = this.getUser();
    console.log('本地存储Token:', token ? '有' : '无');
    console.log('本地存储用户:', user);

    // 从本地存储恢复认证状态
    if (token && user) {
      console.log('从本地存储恢复认证状态');
      this.authState.next({
        isAuthenticated: true,
        token,
        user
      });
    } else {
      console.log('未找到保存的认证信息，需要重新登录');
      // 清除可能的不完整数据
      if (token || user) {
        console.log('清除不完整的认证数据');
        this.clearAuthData();
      }
      // 初始状态设置为未认证
      this.authState.next({
        isAuthenticated: false
      });
    }
  }

  login(username: string, password: string): Observable<LoginResponse> {
    console.log('开始登录，用户名:', username);
    
    // 调用svc-code登录API
    const apiUrl = '/api/auth/login';
    console.log('登录API:', apiUrl);
    
    const loginData: LoginRequest = {
      user_id: username,
      password: password
    };
    
    return this.http.post<LoginResponse>(apiUrl, loginData).pipe(
      tap(response => {
        console.log('登录响应:', response);
        
        if (response.success && response.data) {
          // 登录成功，保存token和用户信息
          const token = response.data;
          console.log('获取到Token:', token);
          
          this.setToken(token);
          
          // 创建用户信息（后续可以从验证端点获取详细信息）
          const userInfo: UserInfo = {
            user_id: username,
            username: username,
            authenticated: true
          };
          
          this.setUser(userInfo);
          
          this.authState.next({
            isAuthenticated: true,
            token,
            user: userInfo
          });
          
          console.log('登录成功，认证状态更新');
        } else {
          console.warn('登录失败:', response.message || response.error);
          throw new Error(response.message || response.error || '登录失败');
        }
      }),
      catchError(error => {
        console.error('登录失败:', error);
        return throwError(() => error);
      })
    );
  }

  logout() {
    console.log('用户登出');
    this.clearAuthData();
    this.authState.next({
      isAuthenticated: false
    });
    this.router.navigate(['/login']);
  }

  isAuthenticated(): boolean {
    return this.authState.value.isAuthenticated;
  }

  getToken(): string | null {
    // 优先使用内存中的token，保持一致性
    if (this.authState.value.token) {
      return this.authState.value.token;
    }
    // 回退到localStorage
    return localStorage.getItem(this.TOKEN_KEY);
  }

  private setToken(token: string) {
    localStorage.setItem(this.TOKEN_KEY, token);
  }

  private setUser(user: UserInfo) {
    if (user) {
      localStorage.setItem(this.USER_KEY, JSON.stringify(user));
    }
  }

  private getUser(): UserInfo | null {
    const userStr = localStorage.getItem(this.USER_KEY);
    if (userStr) {
      try {
        return JSON.parse(userStr);
      } catch (e) {
        console.error('解析用户信息失败:', e);
        return null;
      }
    }
    return null;
  }

  private clearAuthData() {
    localStorage.removeItem(this.TOKEN_KEY);
    localStorage.removeItem(this.USER_KEY);
  }

  // 获取当前用户信息
  getCurrentUser(): UserInfo | undefined {
    return this.authState.value.user;
  }

  // 获取当前token（用于API调用）
  getAuthToken(): string | null {
    return this.getToken();
  }

  // 验证token有效性（可选，调用验证端点）
  validateToken(): Observable<any> {
    const apiUrl = '/api/auth/validate';
    return this.http.post(apiUrl, {});
  }
}