export type User = {
  id: string;
  name: string;
  color?: string;
  role: 'admin' | 'agent';
  sector?: string;
  email?: string | null;
  company_id?: number | null;
  passwordHash?: string;
};

const USERS_KEY = 'zapbot_users';
const CURRENT_USER_KEY = 'zapbot_current_user';
const DEFAULT_PASSWORD = '1234';
const DEFAULT_COLOR = '#25d366';
const DEFAULT_ROLE: User['role'] = 'agent';
const DEFAULT_SECTOR = 'Atendimento';

function hashPassword(password: string) {
  let hash = 5381;
  for (let i = 0; i < password.length; i += 1) {
    hash = (hash * 33) ^ password.charCodeAt(i);
  }
  return (hash >>> 0).toString(16);
}

const DEFAULT_USERS: User[] = [];

function normalizeUsers(users: User[]) {
  return users.map(user => ({
    ...user,
    role: user.role || DEFAULT_ROLE,
    sector: user.sector || DEFAULT_SECTOR,
    color: user.color || DEFAULT_COLOR,
    passwordHash: user.passwordHash || undefined
  }));
}

function loadUsers(): User[] {
  try {
    const raw = localStorage.getItem(USERS_KEY);
    if (!raw) {
      return DEFAULT_USERS;
    }
    const parsed = JSON.parse(raw);
    if (!Array.isArray(parsed) || parsed.length === 0) {
      return DEFAULT_USERS;
    }
    const normalized = normalizeUsers(parsed as User[]);
    localStorage.setItem(USERS_KEY, JSON.stringify(normalized));
    return normalized;
  } catch (error) {
    return DEFAULT_USERS;
  }
}

function saveUsers(users: User[]) {
  localStorage.setItem(USERS_KEY, JSON.stringify(users));
}

export function getUsers() {
  return loadUsers();
}

export function setUsers(users: User[]) {
  saveUsers(normalizeUsers(users));
  return loadUsers();
}

export function getCurrentUserId() {
  const stored = localStorage.getItem(CURRENT_USER_KEY);
  const users = loadUsers();
  if (stored && users.some(user => user.id === stored)) {
    return stored;
  }
  return null;
}

export function setCurrentUserId(userId: string) {
  const users = loadUsers();
  if (users.some(user => user.id === userId)) {
    localStorage.setItem(CURRENT_USER_KEY, userId);
  }
}

export function clearCurrentUserId() {
  localStorage.removeItem(CURRENT_USER_KEY);
}

export function getUserById(userId: string) {
  const users = loadUsers();
  return users.find(user => user.id === userId) || users[0] || null;
}

export function getCurrentUser() {
  const id = getCurrentUserId();
  return id ? getUserById(id) : null;
}

export function getSectors() {
  const users = loadUsers();
  return Array.from(new Set(users.map(user => user.sector).filter(Boolean))) as string[];
}

export function addUser(payload: Omit<User, 'id' | 'passwordHash'> & { password: string }) {
  const users = loadUsers();
  const id = `u${Date.now()}`;
  const next = [...users, { ...payload, id, passwordHash: hashPassword(payload.password) }];
  saveUsers(next);
  return next;
}

export function updateUser(
  userId: string,
  patch: Partial<Omit<User, 'id' | 'passwordHash'>> & { password?: string }
) {
  const users = loadUsers();
  const next = users.map(user => {
    if (user.id !== userId) return user;
    if (patch.password) {
      const { password, ...rest } = patch;
      return { ...user, ...rest, passwordHash: hashPassword(password) };
    }
    return { ...user, ...patch };
  });
  saveUsers(next);
  return next;
}

export function removeUser(userId: string) {
  const users = loadUsers();
  const next = users.filter(user => user.id !== userId);
  saveUsers(next.length > 0 ? next : DEFAULT_USERS);
  if (getCurrentUserId() === userId) {
    clearCurrentUserId();
  }
  return next;
}

export function authenticateUser(userId: string, password: string) {
  const users = loadUsers();
  const user = users.find(item => item.id === userId);
  if (!user) return false;
  if (!user.passwordHash) return false;
  return user.passwordHash === hashPassword(password);
}