import { ORDER_ACTIONS } from '../actions/orderActions';

const initialState = {
  // Orders list
  orders: [],
  totalOrders: 0,
  currentPage: 1,
  totalPages: 1,
  pageSize: 10,
  hasPrevious: false,
  hasNext: false,

  // Current order (for detail/edit)
  currentOrder: null,

  // Search results
  searchResults: [],
  searchQuery: '',

  // Loading states
  loading: false,
  orderLoading: false,
  searchLoading: false,

  // Error states
  error: null,
  orderError: null,
  searchError: null,

  // Operation states
  creating: false,
  updating: false,
  deleting: false,
};

const orderReducer = (state = initialState, action) => {
  switch (action.type) {
    // Fetch Orders
    case ORDER_ACTIONS.FETCH_ORDERS_REQUEST:
      return {
        ...state,
        loading: true,
        error: null,
      };

    case ORDER_ACTIONS.FETCH_ORDERS_SUCCESS: {
      const { orders, total_count, page, total_pages, limit } = action.payload.data;
      return {
        ...state,
        loading: false,
        orders: orders,
        totalOrders: total_count || orders.length,
        currentPage: page || 1,
        totalPages: total_pages || 1,
        pageSize: limit || 10,
        hasPrevious: page > 1,
        hasNext: page < total_pages,
        error: null,
      };
    }

    case ORDER_ACTIONS.FETCH_ORDERS_FAILURE:
      return {
        ...state,
        loading: false,
        error: action.payload,
      };

    // Fetch Single Order
    case ORDER_ACTIONS.FETCH_ORDER_REQUEST:
      return {
        ...state,
        orderLoading: true,
        orderError: null,
      };

    case ORDER_ACTIONS.FETCH_ORDER_SUCCESS:
      return {
        ...state,
        orderLoading: false,
        currentOrder: action.payload.data,
        orderError: null,
      };

    case ORDER_ACTIONS.FETCH_ORDER_FAILURE:
      return {
        ...state,
        orderLoading: false,
        orderError: action.payload,
      };

    // Create Order
    case ORDER_ACTIONS.CREATE_ORDER_REQUEST:
      return {
        ...state,
        creating: true,
        error: null,
      };

    case ORDER_ACTIONS.CREATE_ORDER_SUCCESS:
      return {
        ...state,
        creating: false,
        orders: [action.payload.data, ...state.orders],
        totalOrders: state.totalOrders + 1,
        error: null,
      };

    case ORDER_ACTIONS.CREATE_ORDER_FAILURE:
      return {
        ...state,
        creating: false,
        error: action.payload,
      };

    // Update Order
    case ORDER_ACTIONS.UPDATE_ORDER_REQUEST:
      return {
        ...state,
        updating: true,
        error: null,
      };

    case ORDER_ACTIONS.UPDATE_ORDER_SUCCESS:
      return {
        ...state,
        updating: false,
        orders: state.orders.map(order =>
          order.id === action.payload.data.id ? action.payload.data : order
        ),
        currentOrder: action.payload.data,
        error: null,
      };

    case ORDER_ACTIONS.UPDATE_ORDER_FAILURE:
      return {
        ...state,
        updating: false,
        error: action.payload,
      };

    // Delete Order
    case ORDER_ACTIONS.DELETE_ORDER_REQUEST:
      return {
        ...state,
        deleting: true,
        error: null,
      };

    case ORDER_ACTIONS.DELETE_ORDER_SUCCESS:
      return {
        ...state,
        deleting: false,
        orders: state.orders.filter(order => order.id !== action.payload),
        totalOrders: state.totalOrders - 1,
        error: null,
      };

    case ORDER_ACTIONS.DELETE_ORDER_FAILURE:
      return {
        ...state,
        deleting: false,
        error: action.payload,
      };

    // Search Orders
    case ORDER_ACTIONS.SEARCH_ORDERS_REQUEST:
      return {
        ...state,
        searchLoading: true,
        searchError: null,
      };

    case ORDER_ACTIONS.SEARCH_ORDERS_SUCCESS:
      return {
        ...state,
        searchLoading: false,
        searchResults: action.payload.data || action.payload,
        searchQuery: action.payload.query || '',
        searchError: null,
      };

    case ORDER_ACTIONS.SEARCH_ORDERS_FAILURE:
      return {
        ...state,
        searchLoading: false,
        searchError: action.payload,
      };

    // Clear States
    case ORDER_ACTIONS.CLEAR_ORDER_ERROR:
      return {
        ...state,
        error: null,
        orderError: null,
        searchError: null,
      };

    case ORDER_ACTIONS.CLEAR_CURRENT_ORDER:
      return {
        ...state,
        currentOrder: null,
        orderError: null,
      };

    default:
      return state;
  }
};

export default orderReducer;